• ffmpeg ts 关于av_seek_frame

    1 ffmpeg命令行

    一般对视频文件的裁剪 我们通过一行 ffmpeg命令行即可实现，比如

    ffmpeg -ss 0.5 - t 3 - i a.mp4 vcodec copy b.mp4

     其中 -ss 放置较前  开启精准seek定位 对于mp4而言 seek将从moov中相关索引表查找 0.5s时刻附近最近的关键帧 （此描述可能不精确）

    ffmpeg根据此命令是如何裁剪呢？

    1.1 命令行入口

    执行代码位置

    fftools/ffmpeg.c 

    1. int main(int argc, char **argv)
    2. {
    3.     int i, ret;
    4.     BenchmarkTimeStamps ti;
    5.  
    6.     init_dynload();
    7.  
    8.     register_exit(ffmpeg_cleanup);
    9.  
    10.     setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
    11.  
    12.     av_log_set_flags(AV_LOG_SKIP_REPEATED);
    13.     parse_loglevel(argc, argv, options);
    14.  
    15.     if(argc>1 && !strcmp(argv[1], "-d")){
    16.         run_as_daemon=1;
    17.         av_log_set_callback(log_callback_null);
    18.         argc--;
    19.         argv++;
    20.     }
    21.  
    22. #if CONFIG_AVDEVICE
    23.     avdevice_register_all();
    24. #endif
    25.     avformat_network_init();
    26.  
    27.     show_banner(argc, argv, options);
    28.  
    29.     /* parse options and open all input/output files */
    30.     ret = ffmpeg_parse_options(argc, argv);
    31.     if (ret < 0)
    32.         exit_program(1);
    33.  
    34.     if (nb_output_files <= 0 && nb_input_files == 0) {
    35.         show_usage();
    36.         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
    37.         exit_program(1);
    38.     }
    39.  
    40.     /* file converter / grab */
    41.     if (nb_output_files <= 0) {
    42.         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
    43.         exit_program(1);
    44.     }
    45.  
    46.     for (i = 0; i < nb_output_files; i++) {
    47.         if (strcmp(output_files[i]->ctx->oformat->name, "rtp"))
    48.             want_sdp = 0;
    49.     }
    50.  
    51.     current_time = ti = get_benchmark_time_stamps();
    52.     if (transcode() < 0)
    53.         exit_program(1);
    54.     if (do_benchmark) {
    55.         int64_t utime, stime, rtime;
    56.         current_time = get_benchmark_time_stamps();
    57.         utime = current_time.user_usec - ti.user_usec;
    58.         stime = current_time.sys_usec  - ti.sys_usec;
    59.         rtime = current_time.real_usec - ti.real_usec;
    60.         av_log(NULL, AV_LOG_INFO,
    61.                "bench: utime=%0.3fs stime=%0.3fs rtime=%0.3fs\n",
    62.                utime / 1000000.0, stime / 1000000.0, rtime / 1000000.0);
    63.     }
    64.     av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" frames successfully decoded, %"PRIu64" decoding errors\n",
    65.            decode_error_stat[0], decode_error_stat[1]);
    66.     if ((decode_error_stat[0] + decode_error_stat[1]) * max_error_rate < decode_error_stat[1])
    67.         exit_program(69);
    68.  
    69.     exit_program(received_nb_signals ? 255 : main_return_code);
    70.     return main_return_code;
    71. }

    1.2 执行流程

    代码流程比较清晰 主要流程如下：

    1.3 输入上下文设置 

    ffmpeg将解析的参数存放到OptionParseContext中包含输入及输出参数设置，然后进入输入上下文

    根据之前解析的数据OptionPareseContext作为参数传入，确定好seek点，然后调用 avformat_seek_file 

    1. static int open_input_file(OptionsContext *o, const char *filename)
    2. {
    3.     InputFile *f;
    4.     AVFormatContext *ic;
    5.     AVInputFormat *file_iformat = NULL;
    6.     int err, i, ret;
    7.     int64_t timestamp;
    8.     AVDictionary *unused_opts = NULL;
    9.     AVDictionaryEntry *e = NULL;
    10.     char *   video_codec_name = NULL;
    11.     char *   audio_codec_name = NULL;
    12.     char *subtitle_codec_name = NULL;
    13.     char *    data_codec_name = NULL;
    14.     int scan_all_pmts_set = 0;
    15.  
    16.     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
    17.         o->stop_time = INT64_MAX;
    18.         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
    19.     }
    20.  
    21.     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
    22.         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
    23.         if (o->stop_time <= start_time) {
    24.             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
    25.             exit_program(1);
    26.         } else {
    27.             o->recording_time = o->stop_time - start_time;
    28.         }
    29.     }
    30.  
    31.     if (o->format) {
    32.         if (!(file_iformat = av_find_input_format(o->format))) {
    33.             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
    34.             exit_program(1);
    35.         }
    36.     }
    37.  
    38.     if (!strcmp(filename, "-"))
    39.         filename = "pipe:";
    40.  
    41.     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
    42.                          strcmp(filename, "/dev/stdin");
    43.  
    44.     /* get default parameters from command line */
    45.     ic = avformat_alloc_context();
    46.     if (!ic) {
    47.         print_error(filename, AVERROR(ENOMEM));
    48.         exit_program(1);
    49.     }
    50.     if (o->nb_audio_sample_rate) {
    51.         av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
    52.     }
    53.     if (o->nb_audio_channels) {
    54.         /* because we set audio_channels based on both the "ac" and
    55.          * "channel_layout" options, we need to check that the specified
    56.          * demuxer actually has the "channels" option before setting it */
    57.         if (file_iformat && file_iformat->priv_class &&
    58.             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
    59.                         AV_OPT_SEARCH_FAKE_OBJ)) {
    60.             av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
    61.         }
    62.     }
    63.     if (o->nb_frame_rates) {
    64.         /* set the format-level framerate option;
    65.          * this is important for video grabbers, e.g. x11 */
    66.         if (file_iformat && file_iformat->priv_class &&
    67.             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
    68.                         AV_OPT_SEARCH_FAKE_OBJ)) {
    69.             av_dict_set(&o->g->format_opts, "framerate",
    70.                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
    71.         }
    72.     }
    73.     if (o->nb_frame_sizes) {
    74.         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
    75.     }
    76.     if (o->nb_frame_pix_fmts)
    77.         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
    78.  
    79.     MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
    80.     MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
    81.     MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
    82.     MATCH_PER_TYPE_OPT(codec_names, str,     data_codec_name, ic, "d");
    83.  
    84.     if (video_codec_name)
    85.         ic->video_codec    = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
    86.     if (audio_codec_name)
    87.         ic->audio_codec    = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
    88.     if (subtitle_codec_name)
    89.         ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
    90.     if (data_codec_name)
    91.         ic->data_codec     = find_codec_or_die(data_codec_name    , AVMEDIA_TYPE_DATA    , 0);
    92.  
    93.     ic->video_codec_id     = video_codec_name    ? ic->video_codec->id    : AV_CODEC_ID_NONE;
    94.     ic->audio_codec_id     = audio_codec_name    ? ic->audio_codec->id    : AV_CODEC_ID_NONE;
    95.     ic->subtitle_codec_id  = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
    96.     ic->data_codec_id      = data_codec_name     ? ic->data_codec->id     : AV_CODEC_ID_NONE;
    97.  
    98.     ic->flags |= AVFMT_FLAG_NONBLOCK;
    99.     if (o->bitexact)
    100.         ic->flags |= AVFMT_FLAG_BITEXACT;
    101.     ic->interrupt_callback = int_cb;
    102.  
    103.     if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
    104.         av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
    105.         scan_all_pmts_set = 1;
    106.     }
    107.     /* open the input file with generic avformat function */
    108.     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
    109.     if (err < 0) {
    110.         print_error(filename, err);
    111.         if (err == AVERROR_PROTOCOL_NOT_FOUND)
    112.             av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
    113.         exit_program(1);
    114.     }
    115.     if (scan_all_pmts_set)
    116.         av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
    117.     remove_avoptions(&o->g->format_opts, o->g->codec_opts);
    118.     assert_avoptions(o->g->format_opts);
    119.  
    120.     /* apply forced codec ids */
    121.     for (i = 0; i < ic->nb_streams; i++)
    122.         choose_decoder(o, ic, ic->streams[i]);
    123.  
    124.     if (find_stream_info) {
    125.         AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
    126.         int orig_nb_streams = ic->nb_streams;
    127.  
    128.         /* If not enough info to get the stream parameters, we decode the
    129.            first frames to get it. (used in mpeg case for example) */
    130.         ret = avformat_find_stream_info(ic, opts);
    131.  
    132.         for (i = 0; i < orig_nb_streams; i++)
    133.             av_dict_free(&opts[i]);
    134.         av_freep(&opts);
    135.  
    136.         if (ret < 0) {
    137.             av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
    138.             if (ic->nb_streams == 0) {
    139.                 avformat_close_input(&ic);
    140.                 exit_program(1);
    141.             }
    142.         }
    143.     }
    144.  
    145.     if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
    146.         av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
    147.         o->start_time_eof = AV_NOPTS_VALUE;
    148.     }
    149.  
    150.     if (o->start_time_eof != AV_NOPTS_VALUE) {
    151.         if (o->start_time_eof >= 0) {
    152.             av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
    153.             exit_program(1);
    154.         }
    155.         if (ic->duration > 0) {
    156.             o->start_time = o->start_time_eof + ic->duration;
    157.             if (o->start_time < 0) {
    158.                 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
    159.                 o->start_time = AV_NOPTS_VALUE;
    160.             }
    161.         } else
    162.             av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
    163.     }
    164.     timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
    165.     /* add the stream start time */
    166.     if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
    167.         timestamp += ic->start_time;
    168.  
    169.     /* if seeking requested, we execute it */
    170.     if (o->start_time != AV_NOPTS_VALUE) {
    171.         int64_t seek_timestamp = timestamp;
    172.  
    173.         if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
    174.             int dts_heuristic = 0;
    175.             for (i=0; inb_streams; i++) {
    176.                 const AVCodecParameters *par = ic->streams[i]->codecpar;
    177.                 if (par->video_delay) {
    178.                     dts_heuristic = 1;
    179.                     break;
    180.                 }
    181.             }
    182.             if (dts_heuristic) {
    183.                 seek_timestamp -= 3*AV_TIME_BASE / 23;
    184.             }
    185.         }
    186.         ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
    187.         if (ret < 0) {
    188.             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
    189.                    filename, (double)timestamp / AV_TIME_BASE);
    190.         }
    191.     }
    192.  
    193.     /* update the current parameters so that they match the one of the input stream */
    194.     add_input_streams(o, ic);
    195.  
    196.     /* dump the file content */
    197.     av_dump_format(ic, nb_input_files, filename, 0);
    198.  
    199.     GROW_ARRAY(input_files, nb_input_files);
    200.     f = av_mallocz(sizeof(*f));
    201.     if (!f)
    202.         exit_program(1);
    203.     input_files[nb_input_files - 1] = f;
    204.  
    205.     f->ctx        = ic;
    206.     f->ist_index  = nb_input_streams - ic->nb_streams;
    207.     f->start_time = o->start_time;
    208.     f->recording_time = o->recording_time;
    209.     f->input_ts_offset = o->input_ts_offset;
    210.     f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
    211.     f->nb_streams = ic->nb_streams;
    212.     f->rate_emu   = o->rate_emu;
    213.     f->accurate_seek = o->accurate_seek;
    214.     f->loop = o->loop;
    215.     f->duration = 0;
    216.     f->time_base = (AVRational){ 1, 1 };
    217. #if HAVE_THREADS
    218.     f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
    219. #endif
    220.  
    221.     /* check if all codec options have been used */
    222.     unused_opts = strip_specifiers(o->g->codec_opts);
    223.     for (i = f->ist_index; i < nb_input_streams; i++) {
    224.         e = NULL;
    225.         while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
    226.                                 AV_DICT_IGNORE_SUFFIX)))
    227.             av_dict_set(&unused_opts, e->key, NULL, 0);
    228.     }
    229.  
    230.     e = NULL;
    231.     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
    232.         const AVClass *class = avcodec_get_class();
    233.         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
    234.                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
    235.         const AVClass *fclass = avformat_get_class();
    236.         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
    237.                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
    238.         if (!option || foption)
    239.             continue;
    240.  
    241.  
    242.         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
    243.             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
    244.                    "input file #%d (%s) is not a decoding option.\n", e->key,
    245.                    option->help ? option->help : "", nb_input_files - 1,
    246.                    filename);
    247.             exit_program(1);
    248.         }
    249.  
    250.         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
    251.                "input file #%d (%s) has not been used for any stream. The most "
    252.                "likely reason is either wrong type (e.g. a video option with "
    253.                "no video streams) or that it is a private option of some decoder "
    254.                "which was not actually used for any stream.\n", e->key,
    255.                option->help ? option->help : "", nb_input_files - 1, filename);
    256.     }
    257.     av_dict_free(&unused_opts);
    258.  
    259.     for (i = 0; i < o->nb_dump_attachment; i++) {
    260.         int j;
    261.  
    262.         for (j = 0; j < ic->nb_streams; j++) {
    263.             AVStream *st = ic->streams[j];
    264.  
    265.             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
    266.                 dump_attachment(st, o->dump_attachment[i].u.str);
    267.         }
    268.     }
    269.  
    270.     input_stream_potentially_available = 1;
    271.  
    272.     return 0;
    273. }

    1.4 avformat_seek_file

    1. int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
    2.                        int64_t ts, int64_t max_ts, int flags)
    3. {
    4.     if (min_ts > ts || max_ts < ts)
    5.         return -1;
    6.     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
    7.         return AVERROR(EINVAL);
    8.  
    9.     if (s->seek2any>0)
    10.         flags |= AVSEEK_FLAG_ANY;
    11.     flags &= ~AVSEEK_FLAG_BACKWARD;
    12.  
    13.     if (s->iformat->read_seek2) {
    14.         int ret;
    15.         ff_read_frame_flush(s);
    16.  
    17.         if (stream_index == -1 && s->nb_streams == 1) {
    18.             AVRational time_base = s->streams[0]->time_base;
    19.             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
    20.             min_ts = av_rescale_rnd(min_ts, time_base.den,
    21.                                     time_base.num * (int64_t)AV_TIME_BASE,
    22.                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
    23.             max_ts = av_rescale_rnd(max_ts, time_base.den,
    24.                                     time_base.num * (int64_t)AV_TIME_BASE,
    25.                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
    26.             stream_index = 0;
    27.         }
    28.  
    29.         ret = s->iformat->read_seek2(s, stream_index, min_ts,
    30.                                      ts, max_ts, flags);
    31.  
    32.         if (ret >= 0)
    33.             ret = avformat_queue_attached_pictures(s);
    34.         return ret;
    35.     }
    36.  
    37.     if (s->iformat->read_timestamp) {
    38.         // try to seek via read_timestamp()
    39.     }
    40.  
    41.     // Fall back on old API if new is not implemented but old is.
    42.     // Note the old API has somewhat different semantics.
    43.     if (s->iformat->read_seek || 1) {
    44.         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
    45.         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
    46.         if (ret<0 && ts != min_ts && max_ts != ts) {
    47.             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
    48.             if (ret >= 0)
    49.                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
    50.         }
    51.         return ret;
    52.     }
    53.  
    54.     // try some generic seek like seek_frame_generic() but with new ts semantics
    55.     return -1; //unreachable
    56. }

    ffmpeg中大部分fromat都定义实现了read_seek ,一般情况下都会调用av_seek_frame，因为输入文件是mp4格式 .format对应 mov ,

    av_ssek_frame->seek_frame_internal-> read_seek ->mov_read_seek

    1.  
    2.  
    3. AVInputFormat ff_mov_demuxer = {
    4.     .name           = "mov,mp4,m4a,3gp,3g2,mj2",
    5.     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
    6.     .priv_class     = &mov_class,
    7.     .priv_data_size = sizeof(MOVContext),
    8.     .extensions     = "mov,mp4,m4a,3gp,3g2,mj2",
    9.     .read_probe     = mov_probe,
    10.     .read_header    = mov_read_header,
    11.     .read_packet    = mov_read_packet,
    12.     .read_close     = mov_read_close,
    13.     .read_seek      = mov_read_seek,
    14.     .flags          = AVFMT_NO_BYTE_SEEK | AVFMT_SEEK_TO_PTS,
    15. };

    真正确定seek位置代码函数 ff_index_search_timestamp flags不同 查询规则有所不同

    1. int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
    2.                               int64_t wanted_timestamp, int flags)
    3. {
    4.     int a, b, m;
    5.     int64_t timestamp;
    6.  
    7.     a = -1;
    8.     b = nb_entries;
    9.  
    10.     // Optimize appending index entries at the end.
    11.     if (b && entries[b - 1].timestamp < wanted_timestamp)
    12.         a = b - 1;
    13.  
    14.     while (b - a > 1) {
    15.         m         = (a + b) >> 1;
    16.  
    17.         // Search for the next non-discarded packet.
    18.         while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
    19.             m++;
    20.             if (m == b && entries[m].timestamp >= wanted_timestamp) {
    21.                 m = b - 1;
    22.                 break;
    23.             }
    24.         }
    25.  
    26.         timestamp = entries[m].timestamp;
    27.         if (timestamp >= wanted_timestamp)
    28.             b = m;
    29.         if (timestamp <= wanted_timestamp)
    30.             a = m;
    31.     }
    32.     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
    33.  
    34.     if (!(flags & AVSEEK_FLAG_ANY))
    35.         while (m >= 0 && m < nb_entries &&
    36.                !(entries[m].flags & AVINDEX_KEYFRAME))
    37.             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
    38.  
    39.     if (m == nb_entries)
    40.         return -1;
    41.     return m;
    42. }

    flags:

    #define AVSEEK_FLAG_BACKGROUND 1              ///<

    #define AVSEEK_FALG_BYTE 　　　　　　　 ///<< 变成一个 byte, 按照文件的大小位置跳到那个位置

    #define AVSEEK_FLAG_ANY 　　　　　　　 ///<<

    #define AVSEEK_FLAG_FRAME 　　　　　　 ///<<

    2  TS 

    对于ts切割格式采用同样的方式分析  mpegts.c , 并未定义 read_seek

    1. AVInputFormat ff_mpegts_demuxer = {
    2.     .name           = "mpegts",
    3.     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
    4.     .priv_data_size = sizeof(MpegTSContext),
    5.     .read_probe     = mpegts_probe,
    6.     .read_header    = mpegts_read_header,
    7.     .read_packet    = mpegts_read_packet,
    8.     .read_close     = mpegts_read_close,
    9.     .read_timestamp = mpegts_get_dts,
    10.     .flags          = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
    11.     .priv_class     = &mpegts_class,
    12. };

    从而进入 ff_seek_frame_binary 方法，由于是实时流没有index_entry 调用ff_gen_search 生成seek pos  gen_seek

    1. int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
    2.                          int64_t target_ts, int flags)
    3. {
    4.     const AVInputFormat *avif = s->iformat;
    5.     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
    6.     int64_t ts_min, ts_max, ts;
    7.     int index;
    8.     int64_t ret;
    9.     AVStream *st;
    10.  
    11.     if (stream_index < 0)
    12.         return -1;
    13.  
    14.     av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
    15.  
    16.     ts_max =
    17.     ts_min = AV_NOPTS_VALUE;
    18.     pos_limit = -1; // GCC falsely says it may be uninitialized.
    19.  
    20.     st = s->streams[stream_index];
    21.     if (st->index_entries) {
    22.         AVIndexEntry *e;
    23.  
    24.         /* FIXME: Whole function must be checked for non-keyframe entries in
    25.          * index case, especially read_timestamp(). */
    26.         index = av_index_search_timestamp(st, target_ts,
    27.                                           flags | AVSEEK_FLAG_BACKWARD);
    28.         index = FFMAX(index, 0);
    29.         e     = &st->index_entries[index];
    30.  
    31.         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
    32.             pos_min = e->pos;
    33.             ts_min  = e->timestamp;
    34.             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
    35.                     pos_min, av_ts2str(ts_min));
    36.         } else {
    37.             av_assert1(index == 0);
    38.         }
    39.  
    40.         index = av_index_search_timestamp(st, target_ts,
    41.                                           flags & ~AVSEEK_FLAG_BACKWARD);
    42.         av_assert0(index < st->nb_index_entries);
    43.         if (index >= 0) {
    44.             e = &st->index_entries[index];
    45.             av_assert1(e->timestamp >= target_ts);
    46.             pos_max   = e->pos;
    47.             ts_max    = e->timestamp;
    48.             pos_limit = pos_max - e->min_distance;
    49.             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
    50.                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
    51.         }
    52.     }
    53.  
    54.     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
    55.                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
    56.     if (pos < 0)
    57.         return -1;
    58.  
    59.     /* do the seek */
    60.     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
    61.         return ret;
    62.  
    63.     ff_read_frame_flush(s);
    64.     ff_update_cur_dts(s, st, ts);
    65.  
    66.     return 0;
    67. }

    注意avid->read_timestamap  mpegts 将通过mpegts_get_dts 通过时间戳查询pos

    1. AVInputFormat ff_mpegts_demuxer = {
    2.     .name           = "mpegts",
    3.     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
    4.     .priv_data_size = sizeof(MpegTSContext),
    5.     .read_probe     = mpegts_probe,
    6.     .read_header    = mpegts_read_header,
    7.     .read_packet    = mpegts_read_packet,
    8.     .read_close     = mpegts_read_close,
    9.     .read_timestamp = mpegts_get_dts,
    10.     .flags          = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
    11.     .priv_class     = &mpegts_class,
    12. };
    1. static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index,
    2.                               int64_t *ppos, int64_t pos_limit)
    3. {
    4.     MpegTSContext *ts = s->priv_data;
    5.     int64_t pos;
    6.     int pos47 = ts->pos47_full % ts->raw_packet_size;
    7.     pos = ((*ppos  + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * ts->raw_packet_size + pos47;
    8.     ff_read_frame_flush(s);
    9.     if (avio_seek(s->pb, pos, SEEK_SET) < 0)
    10.         return AV_NOPTS_VALUE;
    11.     while(pos < pos_limit) {
    12.         int ret;
    13.         AVPacket pkt;
    14.         av_init_packet(&pkt);
    15.         ret = av_read_frame(s, &pkt);
    16.         if (ret < 0)
    17.             return AV_NOPTS_VALUE;
    18.         if (pkt.dts != AV_NOPTS_VALUE && pkt.pos >= 0) {
    19.             ff_reduce_index(s, pkt.stream_index);
    20.             av_add_index_entry(s->streams[pkt.stream_index], pkt.pos, pkt.dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
    21.             if (pkt.stream_index == stream_index && pkt.pos >= *ppos) {
    22.                 int64_t dts = pkt.dts;
    23.                 *ppos = pkt.pos;
    24.                 av_packet_unref(&pkt);
    25.                 return dts;
    26.             }
    27.         }
    28.         pos = pkt.pos;
    29.         av_packet_unref(&pkt);
    30.     }
    31.  
    32.     return AV_NOPTS_VALUE;
    33. }

    未完待续

  • 相关阅读:
    二十四节气-白露 | 白露至，秋实美
    算法题java
    为什么那么多人选择找app外包公司，而不是自己组建团队开发app呢？
    【软件测试】8年资深测试说出来我们的心声......
    为什么反射慢？
    TensorFlow实战教程（二十八）-Keras实现BiLSTM微博情感分类和LDA主题挖掘分析
    FLOPS的计算
    长安链大规模数据存储及数据膨胀分析
    计算某个整数含有几位数
    linux文件的隐藏属性、特殊属性和ACL权限
  • 原文地址：https://blog.csdn.net/TyearLin/article/details/132733039