• FFmpeg封装函数avformat_open_input()

    FFmpeg在调用avformat_open_input()之后，可能码流信息不够完整，可以使用avformat_find_stream_info()获取更多的码流信息。比如获取视频帧率、视频宽高，重新计算最大分析时长，打开解码器解码获取codec数据。

    函数原型如下：

    int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);

    参数类型：

    ic：AVFormatContext结构体的指针。该参数用于存储打开的媒体文件的信息。
    当该函数成功返回时，AVFormatContext结构体中将存储媒体文件的相关信息。

    options：AVDictionary是一个结构体，是一对键值对key/value，经常使用AVDictionary设置或读取内部参数。

    1. int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
    2. {
    3.     /*** 第一部分：申明一些局部变量，并初始化 ***/
    4.     int i, count = 0, ret = 0, j;
    5.     int64_t read_size;
    6.     AVStream *st;
    7.     AVCodecContext *avctx;
    8.     AVPacket pkt1, *pkt;
    9.     // 获取已消费完毕的数据对应于文件偏移量，注意不是已读取数据对应文件偏移量
    10.     int64_t old_offset  = avio_tell(ic->pb);
    11.     // new streams might appear, no options for those
    12.     // 在avformat_open_input函数中可能已经new出AVStream，nb_streams也对应流个数
    13.     int orig_nb_streams = ic->nb_streams;
    14.     int flush_codecs;
    15.     // 在AVFormatContext初始化中已经设置该值为默认值0
    16.     int64_t max_analyze_duration = ic->max_analyze_duration;
    17.     int64_t max_stream_analyze_duration;
    18.     int64_t max_subtitle_analyze_duration;
    19.     // 在AVFormatContext初始化中已经设置该值为默认值为5000000
    20.     int64_t probesize = ic->probesize;
    21.     int eof_reached = 0;
    22.     // 若在avformat_open_input分析输入封装格式时，会读取文件头部来看是否存在流来给missing_streams赋值
    23.     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
    24.  
    25.     flush_codecs = probesize > 0;
    26.  
    27.     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
    28.  
    29.     // 由于max_analyze_duration大概率为0(因为被初始化为0，中间被修改的概率比较小)，因此一般情况下，会进入if(){...}语句中执行
    30.     max_stream_analyze_duration = max_analyze_duration;
    31.     max_subtitle_analyze_duration = max_analyze_duration;
    32.     if (!max_analyze_duration) {
    33.         // 分析流的最大时长和分析文件的最大时长均设置为5倍AV_TIME_BASE, AV_TIME_BASE为1000000，而max_stream_analyze_duration和max_analyze_duration单位刚好为微妙，结合起来正好描述为5s重
    34.         max_stream_analyze_duration =
    35.         max_analyze_duration        = 5*AV_TIME_BASE;
    36.         // 同理，分析字幕时的时长为30s                    
    37.         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
    38.         // 如果是flv文件格式，流分析时长延长到90s
    39.         if (!strcmp(ic->iformat->name, "flv"))
    40.             max_stream_analyze_duration = 90*AV_TIME_BASE;
    41.         // 如果是mpeg格式，mpegts格式，流分析时长为7s
    42.         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
    43.             max_stream_analyze_duration = 7*AV_TIME_BASE;
    44.     }
    45.  
    46.     // 如果AVIOContext已经存在，那么也许已经读取了数据，这儿输出当前io读取情况。
    47.     // avio_tell(ic->pb)输出已读取并处理完的数据偏移位置（文件偏移量），
    48.     // bytes_read为已读取数据字节数，seek_count是已经做过多少次seek操作， nb_streams为流个数
    49.     if (ic->pb)
    50.         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
    51.                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
    52.  
    53.     // 第一个for循环，做什么的？
    54.     // 赋值AVStream->AVStreamInternal编码器参数值，并通过打开流的解码器来验证这些参数值是否正确
    55.     for (i = 0; i < ic->nb_streams; i++) {
    56.         const AVCodec *codec;
    57.         AVDictionary *thread_opt = NULL;
    58.         st = ic->streams[i];
    59.         avctx = st->internal->avctx;
    60.  
    61.         // 在文件格式读取文件头的函数中，会解析并给AVStream->time_base时间基赋值
    62.         // 复制时间基到AVStream->AVStreamInternal->AVCodecContext->time_base中
    63.         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
    64.             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
    65. /*            if (!st->time_base.num)
    66.                 st->time_base = */
    67.             if (!avctx->time_base.num)
    68.                 avctx->time_base = st->time_base;
    69.         }
    70.  
    71.         // 外部用户修改了AVStream的AVCodecContext，那么这儿保持AVStream的AVCodecParameters中 
    72.         // codec_id, codec_type, AVStream的AVStreamInternal中的orig_codec_id，与AVStream的 
    73.         // AVCodecContext中的数据保持一致。
    74.         /* check if the caller has overridden the codec id */
    75. #if FF_API_LAVF_AVCTX
    76. FF_DISABLE_DEPRECATION_WARNINGS
    77.         if (st->codec->codec_id != st->internal->orig_codec_id) {
    78.             st->codecpar->codec_id   = st->codec->codec_id;
    79.             st->codecpar->codec_type = st->codec->codec_type;
    80.             st->internal->orig_codec_id = st->codec->codec_id;
    81.         }
    82. FF_ENABLE_DEPRECATION_WARNINGS
    83. #endif
    84.  
    85.         // 查看流分析需不需要解析器，解析器用来从流中分离出单独的视频帧和音频帧
    86.         // only for the split stuff
    87.         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
    88.             st->parser = av_parser_init(st->codecpar->codec_id);
    89.             if (st->parser) {
    90.                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
    91.                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
    92.                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
    93.                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
    94.                 }
    95.             } else if (st->need_parsing) {
    96.                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
    97.                        "%s, packets or times may be invalid.\n",
    98.                        avcodec_get_name(st->codecpar->codec_id));
    99.             }
    100.         }
    101.  
    102.  
    103.         // 确保AVStream->AVStreaminternal中关于编解码器的相关参数正确
    104.         if (st->codecpar->codec_id != st->internal->orig_codec_id)
    105.             st->internal->orig_codec_id = st->codecpar->codec_id;
    106.         ret = avcodec_parameters_to_context(avctx, st->codecpar); // 复制编解码器参数
    107.         if (ret < 0)
    108.             goto find_stream_info_err;
    109.         if (st->request_probe <= 0)
    110.             st->internal->avctx_inited = 1; // 设置初始化标志位
    111.  
    112.         // 查找解码器
    113.         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
    114.  
    115.         // 设置解码线程为1个
    116.         /* Force thread count to 1 since the H.264 decoder will not extract
    117.          * SPS and PPS to extradata during multi-threaded decoding. */
    118.         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
    119.  
    120.         if (ic->codec_whitelist)
    121.             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
    122.  
    123.         // 对于字幕流，尝试打开解码器，确保字幕头是否正确的设置
    124.         /* Ensure that subtitle_header is properly set. */
    125.         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
    126.             && codec && !avctx->codec) {
    127.             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
    128.                 av_log(ic, AV_LOG_WARNING,
    129.                        "Failed to open codec in %s\n",__FUNCTION__);
    130.         }
    131.  
    132.         // 尝试打开解码器，看是否已获得足够的编解码参数
    133.         // Try to just open decoders, in case this is enough to get parameters.
    134.         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
    135.             if (codec && !avctx->codec)
    136.                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
    137.                     av_log(ic, AV_LOG_WARNING,
    138.                            "Failed to open codec in %s\n",__FUNCTION__);
    139.         }
    140.         if (!options)
    141.             av_dict_free(&thread_opt);
    142.     }
    143.  
    144.     // 第二个for循环，做什么的？
    145.     // 给AVStream内部使用的info结构体的一些成员赋初始值，这几个成员用于平均帧率估计
    146.     for (i = 0; i < ic->nb_streams; i++) {
    147. #if FF_API_R_FRAME_RATE
    148.         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
    149. #endif
    150.         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
    151.         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
    152.     }
    153.  
    154.     // 第三个for循环，死循环，做什么的？
    155.     // 
    156.     read_size = 0;
    157.     for (;;) {
    158.         int analyzed_all_streams;
    159.         // 检测是否有外部中断，可以帮助快速退出循环，终止程序运行，ic->interrupt_callback
    160.         // 由用户定义，因此，何时需要终止程序是受用户支配的。
    161.         if (ff_check_interrupt(&ic->interrupt_callback)) {
    162.             ret = AVERROR_EXIT;
    163.             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
    164.             break;
    165.         }
    166.  
    167.         // 
    168.         /* check if one codec still needs to be handled */
    169.         for (i = 0; i < ic->nb_streams; i++) {
    170.             int fps_analyze_framecount = 20;
    171.             int count;
    172.  
    173.             st = ic->streams[i];
    174.             if (!has_codec_parameters(st, NULL))
    175.                 break;
    176.             /* If the timebase is coarse (like the usual millisecond precision
    177.              * of mkv), we need to analyze more frames to reliably arrive at
    178.              * the correct fps. */
    179.             if (av_q2d(st->time_base) > 0.0005)
    180.                 fps_analyze_framecount *= 2;
    181.             if (!tb_unreliable(st->internal->avctx))
    182.                 fps_analyze_framecount = 0;
    183.             if (ic->fps_probe_size >= 0)
    184.                 fps_analyze_framecount = ic->fps_probe_size;
    185.             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
    186.                 fps_analyze_framecount = 0;
    187.             /* variable fps and no guess at the real fps */
    188.             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
    189.                        st->info->codec_info_duration_fields/2 :
    190.                        st->info->duration_count;
    191.             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
    192.                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
    193.                 if (count < fps_analyze_framecount)
    194.                     break;
    195.             }
    196.             // Look at the first 3 frames if there is evidence of frame delay
    197.             // but the decoder delay is not set.
    198.             if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
    199.                 break;
    200.             if (!st->internal->avctx->extradata &&
    201.                 (!st->internal->extract_extradata.inited ||
    202.                  st->internal->extract_extradata.bsf) &&
    203.                 extract_extradata_check(st))
    204.                 break;
    205.             if (st->first_dts == AV_NOPTS_VALUE &&
    206.                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
    207.                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
    208.                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
    209.                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
    210.                 break;
    211.         }
    212.         analyzed_all_streams = 0;
    213.         if (!missing_streams || !*missing_streams)
    214.         if (i == ic->nb_streams) {
    215.             analyzed_all_streams = 1;
    216.             /* NOTE: If the format has no header, then we need to read some
    217.              * packets to get most of the streams, so we cannot stop here. */
    218.             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
    219.                 /* If we found the info for all the codecs, we can stop. */
    220.                 ret = count;
    221.                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
    222.                 flush_codecs = 0;
    223.                 break;
    224.             }
    225.         }
    226.         /* We did not get all the codec info, but we read too much data. */
    227.         if (read_size >= probesize) {
    228.             ret = count;
    229.             av_log(ic, AV_LOG_DEBUG,
    230.                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
    231.             for (i = 0; i < ic->nb_streams; i++)
    232.                 if (!ic->streams[i]->r_frame_rate.num &&
    233.                     ic->streams[i]->info->duration_count <= 1 &&
    234.                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
    235.                     strcmp(ic->iformat->name, "image2"))
    236.                     av_log(ic, AV_LOG_WARNING,
    237.                            "Stream #%d: not enough frames to estimate rate; "
    238.                            "consider increasing probesize\n", i);
    239.             break;
    240.         }
    241.  
    242.         /* NOTE: A new stream can be added there if no header in file
    243.          * (AVFMTCTX_NOHEADER). */
    244.         ret = read_frame_internal(ic, &pkt1);
    245.         if (ret == AVERROR(EAGAIN))
    246.             continue;
    247.  
    248.         if (ret < 0) {
    249.             /* EOF or error*/
    250.             eof_reached = 1;
    251.             break;
    252.         }
    253.  
    254.         pkt = &pkt1;
    255.  
    256.         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
    257.             ret = ff_packet_list_put(&ic->internal->packet_buffer,
    258.                                      &ic->internal->packet_buffer_end,
    259.                                      pkt, 0);
    260.             if (ret < 0)
    261.                 goto find_stream_info_err;
    262.         }
    263.  
    264.         st = ic->streams[pkt->stream_index];
    265.         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
    266.             read_size += pkt->size;
    267.  
    268.         avctx = st->internal->avctx;
    269.         if (!st->internal->avctx_inited) {
    270.             ret = avcodec_parameters_to_context(avctx, st->codecpar);
    271.             if (ret < 0)
    272.                 goto find_stream_info_err;
    273.             st->internal->avctx_inited = 1;
    274.         }
    275.  
    276.         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
    277.             /* check for non-increasing dts */
    278.             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
    279.                 st->info->fps_last_dts >= pkt->dts) {
    280.                 av_log(ic, AV_LOG_DEBUG,
    281.                        "Non-increasing DTS in stream %d: packet %d with DTS "
    282.                        "%"PRId64", packet %d with DTS %"PRId64"\n",
    283.                        st->index, st->info->fps_last_dts_idx,
    284.                        st->info->fps_last_dts, st->codec_info_nb_frames,
    285.                        pkt->dts);
    286.                 st->info->fps_first_dts =
    287.                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
    288.             }
    289.             /* Check for a discontinuity in dts. If the difference in dts
    290.              * is more than 1000 times the average packet duration in the
    291.              * sequence, we treat it as a discontinuity. */
    292.             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
    293.                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
    294.                 (pkt->dts - st->info->fps_last_dts) / 1000 >
    295.                 (st->info->fps_last_dts     - (uint64_t)st->info->fps_first_dts) /
    296.                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
    297.                 av_log(ic, AV_LOG_WARNING,
    298.                        "DTS discontinuity in stream %d: packet %d with DTS "
    299.                        "%"PRId64", packet %d with DTS %"PRId64"\n",
    300.                        st->index, st->info->fps_last_dts_idx,
    301.                        st->info->fps_last_dts, st->codec_info_nb_frames,
    302.                        pkt->dts);
    303.                 st->info->fps_first_dts =
    304.                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
    305.             }
    306.  
    307.             /* update stored dts values */
    308.             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
    309.                 st->info->fps_first_dts     = pkt->dts;
    310.                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
    311.             }
    312.             st->info->fps_last_dts     = pkt->dts;
    313.             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
    314.         }
    315.         if (st->codec_info_nb_frames>1) {
    316.             int64_t t = 0;
    317.             int64_t limit;
    318.  
    319.             if (st->time_base.den > 0)
    320.                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
    321.             if (st->avg_frame_rate.num > 0)
    322.                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
    323.  
    324.             if (   t == 0
    325.                 && st->codec_info_nb_frames>30
    326.                 && st->info->fps_first_dts != AV_NOPTS_VALUE
    327.                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
    328.                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
    329.  
    330.             if (analyzed_all_streams)                                limit = max_analyze_duration;
    331.             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
    332.             else                                                     limit = max_stream_analyze_duration;
    333.  
    334.             if (t >= limit) {
    335.                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
    336.                        limit,
    337.                        t, pkt->stream_index);
    338.                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
    339.                     av_packet_unref(pkt);
    340.                 break;
    341.             }
    342.             if (pkt->duration) {
    343.                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
    344.                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
    345.                 } else
    346.                     st->info->codec_info_duration += pkt->duration;
    347.                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
    348.             }
    349.         }
    350.         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
    351. #if FF_API_R_FRAME_RATE
    352.             ff_rfps_add_frame(ic, st, pkt->dts);
    353. #endif
    354.             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
    355.                 st->info->frame_delay_evidence = 1;
    356.         }
    357.         if (!st->internal->avctx->extradata) {
    358.             ret = extract_extradata(st, pkt);
    359.             if (ret < 0)
    360.                 goto find_stream_info_err;
    361.         }
    362.  
    363.         /* If still no information, we try to open the codec and to
    364.          * decompress the frame. We try to avoid that in most cases as
    365.          * it takes longer and uses more memory. For MPEG-4, we need to
    366.          * decompress for QuickTime.
    367.          *
    368.          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
    369.          * least one frame of codec data, this makes sure the codec initializes
    370.          * the channel configuration and does not only trust the values from
    371.          * the container. */
    372.         try_decode_frame(ic, st, pkt,
    373.                          (options && i < orig_nb_streams) ? &options[i] : NULL);
    374.  
    375.         if (ic->flags & AVFMT_FLAG_NOBUFFER)
    376.             av_packet_unref(pkt);
    377.  
    378.         st->codec_info_nb_frames++;
    379.         count++;
    380.     }
    381.  
    382.     if (eof_reached) {
    383.         int stream_index;
    384.         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
    385.             st = ic->streams[stream_index];
    386.             avctx = st->internal->avctx;
    387.             if (!has_codec_parameters(st, NULL)) {
    388.                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
    389.                 if (codec && !avctx->codec) {
    390.                     AVDictionary *opts = NULL;
    391.                     if (ic->codec_whitelist)
    392.                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
    393.                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
    394.                         av_log(ic, AV_LOG_WARNING,
    395.                                "Failed to open codec in %s\n",__FUNCTION__);
    396.                     av_dict_free(&opts);
    397.                 }
    398.             }
    399.  
    400.             // EOF already reached while reading the stream above.
    401.             // So continue with reoordering DTS with whatever delay we have.
    402.             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
    403.                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
    404.             }
    405.         }
    406.     }
    407.  
    408.     if (flush_codecs) {
    409.         AVPacket empty_pkt = { 0 };
    410.         int err = 0;
    411.         av_init_packet(&empty_pkt);
    412.  
    413.         for (i = 0; i < ic->nb_streams; i++) {
    414.  
    415.             st = ic->streams[i];
    416.  
    417.             /* flush the decoders */
    418.             if (st->info->found_decoder == 1) {
    419.                 do {
    420.                     err = try_decode_frame(ic, st, &empty_pkt,
    421.                                             (options && i < orig_nb_streams)
    422.                                             ? &options[i] : NULL);
    423.                 } while (err > 0 && !has_codec_parameters(st, NULL));
    424.  
    425.                 if (err < 0) {
    426.                     av_log(ic, AV_LOG_INFO,
    427.                         "decoding for stream %d failed\n", st->index);
    428.                 }
    429.             }
    430.         }
    431.     }
    432.  
    433.     ff_rfps_calculate(ic);
    434.  
    435.     for (i = 0; i < ic->nb_streams; i++) {
    436.         st = ic->streams[i];
    437.         avctx = st->internal->avctx;
    438.         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
    439.             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
    440.                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
    441.                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
    442.                     avctx->codec_tag= tag;
    443.             }
    444.  
    445.             /* estimate average framerate if not set by demuxer */
    446.             if (st->info->codec_info_duration_fields &&
    447.                 !st->avg_frame_rate.num &&
    448.                 st->info->codec_info_duration) {
    449.                 int best_fps      = 0;
    450.                 double best_error = 0.01;
    451.                 AVRational codec_frame_rate = avctx->framerate;
    452.  
    453.                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
    454.                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
    455.                     st->info->codec_info_duration        < 0)
    456.                     continue;
    457.                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
    458.                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
    459.                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
    460.  
    461.                 /* Round guessed framerate to a "standard" framerate if it's
    462.                  * within 1% of the original estimate. */
    463.                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
    464.                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
    465.                     double error       = fabs(av_q2d(st->avg_frame_rate) /
    466.                                               av_q2d(std_fps) - 1);
    467.                     if (error < best_error) {
    468.                         best_error = error;
    469.                         best_fps   = std_fps.num;
    470.                     }
    471.                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
    472.                         error       = fabs(av_q2d(codec_frame_rate) /
    473.                                            av_q2d(std_fps) - 1);
    474.                         if (error < best_error) {
    475.                             best_error = error;
    476.                             best_fps   = std_fps.num;
    477.                         }
    478.                     }
    479.                 }
    480.                 if (best_fps)
    481.                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
    482.                               best_fps, 12 * 1001, INT_MAX);
    483.             }
    484.             if (!st->r_frame_rate.num) {
    485.                 if (    avctx->time_base.den * (int64_t) st->time_base.num
    486.                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
    487.                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
    488.                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
    489.                 } else {
    490.                     st->r_frame_rate.num = st->time_base.den;
    491.                     st->r_frame_rate.den = st->time_base.num;
    492.                 }
    493.             }
    494.             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
    495.                 AVRational hw_ratio = { avctx->height, avctx->width };
    496.                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
    497.                                                    hw_ratio);
    498.             }
    499.         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
    500.             if (!avctx->bits_per_coded_sample)
    501.                 avctx->bits_per_coded_sample =
    502.                     av_get_bits_per_sample(avctx->codec_id);
    503.             // set stream disposition based on audio service type
    504.             switch (avctx->audio_service_type) {
    505.             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
    506.                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
    507.                 break;
    508.             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
    509.                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
    510.                 break;
    511.             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
    512.                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
    513.                 break;
    514.             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
    515.                 st->disposition = AV_DISPOSITION_COMMENT;
    516.                 break;
    517.             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
    518.                 st->disposition = AV_DISPOSITION_KARAOKE;
    519.                 break;
    520.             }
    521.         }
    522.     }
    523.     if (probesize)
    524.         estimate_timings(ic, old_offset);
    525.     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
    526.     if (ret >= 0 && ic->nb_streams)
    527.         /* We could not have all the codec parameters before EOF. */
    528.         ret = -1;
    529.     for (i = 0; i < ic->nb_streams; i++) {
    530.         const char *errmsg;
    531.         st = ic->streams[i];
    532.         /* if no packet was ever seen, update context now for has_codec_parameters */
    533.         if (!st->internal->avctx_inited) {
    534.             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
    535.                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
    536.                 st->codecpar->format = st->internal->avctx->sample_fmt;
    537.             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
    538.             if (ret < 0)
    539.                 goto find_stream_info_err;
    540.         }
    541.         if (!has_codec_parameters(st, &errmsg)) {
    542.             char buf[256];
    543.             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
    544.             av_log(ic, AV_LOG_WARNING,
    545.                    "Could not find codec parameters for stream %d (%s): %s\n"
    546.                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
    547.                    i, buf, errmsg);
    548.         } else {
    549.             ret = 0;
    550.         }
    551.     }
    552.     compute_chapters_end(ic);
    553.     /* update the stream parameters from the internal codec contexts */
    554.     for (i = 0; i < ic->nb_streams; i++) {
    555.         st = ic->streams[i];
    556.         if (st->internal->avctx_inited) {
    557.             int orig_w = st->codecpar->width;
    558.             int orig_h = st->codecpar->height;
    559.             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
    560.             if (ret < 0)
    561.                 goto find_stream_info_err;
    562. #if FF_API_LOWRES
    563.             // The decoder might reduce the video size by the lowres factor.
    564.             if (st->internal->avctx->lowres && orig_w) {
    565.                 st->codecpar->width = orig_w;
    566.                 st->codecpar->height = orig_h;
    567.             }
    568. #endif
    569.         }
    570. #if FF_API_LAVF_AVCTX
    571. FF_DISABLE_DEPRECATION_WARNINGS
    572.         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
    573.         if (ret < 0)
    574.             goto find_stream_info_err;
    575. #if FF_API_LOWRES
    576.         // The old API (AVStream.codec) "requires" the resolution to be adjusted
    577.         // by the lowres factor.
    578.         if (st->internal->avctx->lowres && st->internal->avctx->width) {
    579.             st->codec->lowres = st->internal->avctx->lowres;
    580.             st->codec->width = st->internal->avctx->width;
    581.             st->codec->height = st->internal->avctx->height;
    582.         }
    583. #endif
    584.         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
    585.             st->codec->time_base = st->internal->avctx->time_base;
    586.             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
    587.         }
    588.         st->codec->framerate = st->avg_frame_rate;
    589.         if (st->internal->avctx->subtitle_header) {
    590.             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
    591.             if (!st->codec->subtitle_header)
    592.                 goto find_stream_info_err;
    593.             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
    594.             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
    595.                    st->codec->subtitle_header_size);
    596.         }
    597.         // Fields unavailable in AVCodecParameters
    598.         st->codec->coded_width = st->internal->avctx->coded_width;
    599.         st->codec->coded_height = st->internal->avctx->coded_height;
    600.         st->codec->properties = st->internal->avctx->properties;
    601. FF_ENABLE_DEPRECATION_WARNINGS
    602. #endif
    603.         st->internal->avctx_inited = 0;
    604.     }
    605. find_stream_info_err:
    606.     for (i = 0; i < ic->nb_streams; i++) {
    607.         st = ic->streams[i];
    608.         if (st->info)
    609.             av_freep(&st->info->duration_error);
    610.         avcodec_close(ic->streams[i]->internal->avctx);
    611.         av_freep(&ic->streams[i]->info);
    612.         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
    613.         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
    614.     }
    615.     if (ic->pb)
    616.         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
    617.                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
    618.     return ret;
    619. }

    --------------------------------------------------------------

    本函数中，先对一部分数据进行声明和初始化，然后有多个类似于for (i = 0; i < ic->nb_streams; i++) {...}的循环处理，还有一个for(;;)死循环的处理。接下来就对整个过程做一个比较详细的分析：

    1 局部变量的申明，以及数据初始化：
          1）int64_t old_offset  = avio_tell(ic->pb);   保存当前文件偏移量，由于avformat_open_input()函数中已经打开文件，并且读取了文件头，因此，文件偏移已经不为0，此时，该变量保存当前的文件偏移
          2）int orig_nb_streams = ic->nb_streams; 保存avformat_open_input()读取文件头时获取的文件中流的个数，注意对于flv这种格式这个值为0.
          3）int64_t max_analyze_duration = ic->max_analyze_duration; 保存最大的分析时长，ic->max_analyze_duration在构建AVFormatContext过程中被初始化为0，单位微妙
          4）int64_t probesize = ic->probesize; 保存进行探测的数据大小，在AVFormatContext初始化中已经设置该值为默认值为5000000，5MB大小。
          5）int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams"); 保存文件中是否存在流的指示。FFMPEG4.1源码分析之 媒体打开函数avformat_open_input()中分析了flv_read_header()函数中就对该值进行了阐述，该值不为0，表示有音视频流的存在，为0表示不存在音视频流。
          6) 流分析最大时长，最大分析时长，字幕分析时长的计算：分析时长的基本单位是微妙，而AV_TIME_BASE是1000000，那么可以由源码得知：通用情况下，流分析最大时长和最大分析时长为5*AV_TIME_BASE，即5s，字幕分析时长为30*AV_TIME_BASE，即30s；特殊情况下，比如文件格式为flv格式，那么流分析最大时长更新为90*AV_TIME_BASE，即90s，如果文件格式为mpeg或者是mpegts格式，那么流分析最大时长更新为7*AV_TIME_BASE，即7s。

    2 第一次for循环遍历每个流：

         1）复制时间基到AVStream->AVStreamInternal->AVCodecContext->time_base： 在文件格式读取文件头的函数中，会解析并给AVStream->time_base时间基赋值，此处将该时间基复制一份到AVStream->AVStreamInternal->AVCodecContext->time_base中，因为后续的解码，解码器使用AVStream->AVStreamInternal中的数据。
         2）检查用户是否修改了解码器：外部用户修改了AVStream->AVCodecContext中的编解码器，那么这儿保持AVStream->AVCodecParameters->codec_id, codec_type, AVStream->AVStreamInternal->orig_codec_id与修改后的一致。
         3）创建流的解析器：解析器用来从原始码流中分离出单独的一帧视频或音频，按需创建。
         4）检查AVStream->AVStreaminternal中的编解码参数都被合理赋值：一方面是AVStream->AVStreaminternal->orig_codec_id要赋值为AVStream->codecpar->codec_id，AVStream->codecpar->codec_id在媒体打开函数avformat_open_input(）中已经通过文件格式读取文件头的函数获知到正确的codec_id；另一方面AVStream->AVStreaminternal->AVCodecContext编解码器上下文从AVStream->AVCodecParamters中拷贝一份编解码参数，因为文件格式读取文件头的函数会分析文件头并给AVStream->AVCodecParamters赋值。
         5）查找解码器，并打开解码器，从而对上述的解码器参数是否正确进行预判。
         6）总结：由上分析可知，第一次for循环遍历流，目的在于给流的AVStream->AVStreamInternal中的编码器相关参数赋值（时间戳time_base，编码器orig_codec_id，编码器上下文结构avctx）；然后找到每个流的解码器，通过打开解码器是否成功来验证上述赋值的编解码器参数是否正确。

    2 第二次for循环遍历每个流：

        本次遍历是对AVStream->info结构体的部分成员赋初始值，该结构体用于存储流信息，且仅供avformat_find_stream_info()函数使用。此次赋值的几个变量是用来进行平均帧率估计的参数。

    3 第三次for循环，for(;;)死循环：

            使用ff_check_interrupt(&ic->interrupt_callback) 检测是否有外部中断，可以帮助快速退出循环，终止程序运行，ic->interrupt_callback由用户定义，并在构建AVFormatContext对象时传入，因此，何时需要终止程序是受用户支配的。

  • 相关阅读:
    Speedpdf在线转换教你如何XPS转PDF格式
    【ai】李沐 动手深度学学v2 环境安装：anaconda3、pycharm、d2
    百度云原生产品 6 月刊 | CCE 节点组支持配置多个备选机型、CCR 新增镜像加速功能
    leetcode：1648. 销售价值减少的颜色球【二分找边界】
    【编程题】【Scratch三级】2021.12跳高比赛
    Docker 与 K8S学习笔记（二十二）—— 高效使用kubectl的小技巧
    weixin支付
    dashboard中虚拟机冷迁移失败后虚拟机回退到正常状态流程、openstack数据库中修改虚拟机信息流程
    武汉新时标文化传媒有限公司短视频内容该怎么样去运营？
    Qt Core篇 后端上位机界面开发
  • 原文地址：https://blog.csdn.net/weixin_44651073/article/details/136610362