ffmpeg源码分析：transcode()函数

还是先看一下主函数吧:(省略了很多无关大雅的代码)

int main(int argc, char **argv)
{
    OptionsContext o = { 0 };
    int64_t ti;

    //与命令行分析有关的结构的初始化,下面不再罗嗦
    reset_options(&o, 0);

    //设置日志级别
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
    parse_loglevel(argc, argv, options);

    if (argc > 1 && !strcmp(argv[1], "-d"))  {
        run_as_daemon = 1;
        av_log_set_callback(log_callback_null);
        argc--;
        argv++;
    }

    //注册组件们
    avcodec_register_all();
#if CONFIG_AVDEVICE
    avdevice_register_all();
#endif
#if CONFIG_AVFILTER
    avfilter_register_all();
#endif
    av_register_all();
    //初始化网络,windows下需要
    avformat_network_init();

    show_banner();

    term_init();

    //分析命令行输入的参数们
    parse_options(&o, argc, argv, options, opt_output_file);

    //文件的转换就在此函数中发生
    if (transcode(output_files, nb_output_files, input_files, nb_input_files)< 0)
        exit_program(1);

    exit_program(0);
    return 0;
}

下面是transcode()函数,转换就发生在它里面.不废话,看注释吧,应很详细了

static int transcode(
        OutputFile *output_files,//输出文件数组
        int nb_output_files,//输出文件的数量
        InputFile *input_files,//输入文件数组
        int nb_input_files)//输入文件的数量
{
    int ret, i;
    AVFormatContext *is, *os;
    OutputStream *ost;
    InputStream *ist;
    uint8_t *no_packet;
    int no_packet_count = 0;
    int64_t timer_start;
    int key;

    if (!(no_packet = av_mallocz(nb_input_files)))
        exit_program(1);

    //设置编码参数,打开所有输出流的编码器,打开所有输入流的解码器,写入所有输出文件的文件头,于是准备好了
    ret = transcode_init(output_files, nb_output_files, input_files,nb_input_files);
    if (ret < 0)
        goto fail;

    if (!using_stdin){
        av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help
");
    }

    timer_start = av_gettime();

    //循环,直到收到系统信号才退出
    for (; received_sigterm == 0;)
    {
        int file_index, ist_index;
        AVPacket pkt;
        int64_t ipts_min;
        double opts_min;
        int64_t cur_time = av_gettime();

        ipts_min = INT64_MAX;
        opts_min = 1e100;
        /* if 'q' pressed, exits */
        if (!using_stdin)
        {
            //先查看用户按下了什么键,跟据键做出相应的反应
            static int64_t last_time;
            if (received_nb_signals)
                break;
            /* read_key() returns 0 on EOF */
            if (cur_time - last_time >= 100000 && !run_as_daemon){
                key = read_key();
                last_time = cur_time;
            }else{
<span>          </span>.................................
        }

        /* select the stream that we must read now by looking at the
         smallest output pts */
        //下面这个循环的目的是找一个最小的输出pts(也就是离当前最近的)的输出流
        file_index = -1;
        for (i = 0; i < nb_output_streams; i++){
            OutputFile *of;
            int64_t ipts;
            double opts;
            ost = &output_streams[i];//循环每一个输出流
            of = &output_files[ost->file_index];//输出流对应的输出文件
            os = output_files[ost->file_index].ctx;//输出流对应的FormatContext
            ist = &input_streams[ost->source_index];//输出流对应的输入流

            if (ost->is_past_recording_time || //是否过了录制时间?(可能用户指定了一个录制时间段)
                    no_packet[ist->file_index]|| //对应的输入流这个时间内没有数据?
                    (os->pb && avio_tell(os->pb) >= of->limit_filesize))//是否超出了录制范围(也是用户指定的)
                continue;//是的,符合上面某一条,那么再看下一个输出流吧

            //判断当前输入流所在的文件是否可以使用(我也不很明白)
            opts = ost->st->pts.val * av_q2d(ost->st->time_base);
            ipts = ist->pts;
            if (!input_files[ist->file_index].eof_reached)   {
                if (ipts < ipts_min){
                    //每找到一个pts更小的输入流就记录下来,这样循环完所有的输出流时就找到了
                    //pts最小的输入流,及输入文件的序号
                    ipts_min = ipts;
                    if (input_sync)
                        file_index = ist->file_index;
                }
                if (opts < opts_min){
                    opts_min = opts;
                    if (!input_sync)
                        file_index = ist->file_index;
                }
            }

            //难道下面这句话的意思是:如果当前的输出流已接收的帧数,超出用户指定的输出最大帧数时,
            //则当前输出流所属的输出文件对应的所有输出流,都算超过了录像时间?
            if (ost->frame_number >= ost->max_frames){
                int j;
                for (j = 0; j < of->ctx->nb_streams; j++)
                    output_streams[of->ost_index + j].is_past_recording_time =   1;
                continue;
            }
        }
        /* if none, if is finished */
        if (file_index < 0)  {
            //如果没有找到合适的输入文件
            if (no_packet_count){
                //如果是因为有的输入文件暂时得不到数据,则还不算是结束
                no_packet_count = 0;
                memset(no_packet, 0, nb_input_files);
                usleep(10000);
                continue;
            }
            //全部转换完成了,跳出大循环
            break;
        }

        //从找到的输入文件中读出一帧(可能是音频也可能是视频),并放到fifo队列中
        is = input_files[file_index].ctx;
        ret = av_read_frame(is, &pkt);
        if (ret == AVERROR(EAGAIN)) {
            //此时发生了暂时没数据的情况
            no_packet[file_index] = 1;
            no_packet_count++;
            continue;
        }

        //下文判断是否有输入文件到最后了
        if (ret < 0){
            input_files[file_index].eof_reached = 1;
            if (opt_shortest)
                break;
            else
                continue;
        }

        no_packet_count = 0;
        memset(no_packet, 0, nb_input_files);

        if (do_pkt_dump){
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
                    is->streams[pkt.stream_index]);
        }
        /* the following test is needed in case new streams appear
         dynamically in stream : we ignore them */
        //如果在输入文件中遇到一个忽然冒出的流,那么我们不鸟它
        if (pkt.stream_index >= input_files[file_index].nb_streams)
            goto discard_packet;

        //取得当前获得的帧对应的输入流
        ist_index = input_files[file_index].ist_index + pkt.stream_index;
        ist = &input_streams[ist_index];
        if (ist->discard)
            goto discard_packet;

        //重新鼓捣一下帧的时间戳
        if (pkt.dts != AV_NOPTS_VALUE)
            pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset,
                    AV_TIME_BASE_Q, ist->st->time_base);
        if (pkt.pts != AV_NOPTS_VALUE)
            pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset,
                    AV_TIME_BASE_Q, ist->st->time_base);

        if (pkt.pts != AV_NOPTS_VALUE)
            pkt.pts *= ist->ts_scale;
        if (pkt.dts != AV_NOPTS_VALUE)
            pkt.dts *= ist->ts_scale;

        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
                && (is->iformat->flags & AVFMT_TS_DISCONT))
        {
            int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base,
                    AV_TIME_BASE_Q);
            int64_t delta = pkt_dts - ist->next_pts;
            if ((delta < -1LL * dts_delta_threshold * AV_TIME_BASE
                    || (delta > 1LL * dts_delta_threshold * AV_TIME_BASE
                            && ist->st->codec->codec_type
                                    != AVMEDIA_TYPE_SUBTITLE)
                    || pkt_dts + 1 < ist->pts) && !copy_ts)
            {
                input_files[ist->file_index].ts_offset -= delta;
                av_log( NULL,   AV_LOG_DEBUG,
                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"
",
                        delta, input_files[ist->file_index].ts_offset);
                pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q,  ist->st->time_base);
                if (pkt.pts != AV_NOPTS_VALUE)
                    pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q,  ist->st->time_base);
            }
        }

        //把这一帧转换并写入到输出文件中
        if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0){
            av_log(NULL, AV_LOG_ERROR,
                    "Error while decoding stream #%d:%d
",
                    ist->file_index, ist->st->index);
            if (exit_on_error)
                exit_program(1);
            av_free_packet(&pkt);
            continue;
        }

discard_packet:
        av_free_packet(&pkt);

        /* dump report by using the output first video and audio streams */
        print_report(output_files, output_streams, nb_output_streams, 0,
                timer_start, cur_time);
    }

    //文件处理完了,把缓冲中剩余的数据写到输出文件中
    for (i = 0; i < nb_input_streams; i++){
        ist = &input_streams[i];
        if (ist->decoding_needed){
            output_packet(ist, output_streams, nb_output_streams, NULL);
        }
    }
    flush_encoders(output_streams, nb_output_streams);

    term_exit();

    //为输出文件写文件尾(有的不需要).
    for (i = 0; i < nb_output_files; i++){
        os = output_files[i].ctx;
        av_write_trailer(os);
    }

    /* dump report by using the first video and audio streams */
    print_report(output_files, output_streams, nb_output_streams, 1,
            timer_start, av_gettime());

    //关闭所有的编码器
    for (i = 0; i < nb_output_streams; i++){
        ost = &output_streams[i];
        if (ost->encoding_needed){
            av_freep(&ost->st->codec->stats_in);
            avcodec_close(ost->st->codec);
        }
#if CONFIG_AVFILTER
        avfilter_graph_free(&ost->graph);
#endif
    }

    //关闭所有的解码器
    for (i = 0; i < nb_input_streams; i++){
        ist = &input_streams[i];
        if (ist->decoding_needed){
            avcodec_close(ist->st->codec);
        }
    }

    /* finished ! */
    ret = 0;

    fail: av_freep(&bit_buffer);
    av_freep(&no_packet);

    if (output_streams) {
        for (i = 0; i < nb_output_streams; i++)  {
            ost = &output_streams[i];
            if (ost)    {
                if (ost->stream_copy)
                    av_freep(&ost->st->codec->extradata);
                if (ost->logfile){
                    fclose(ost->logfile);
                    ost->logfile = NULL;
                }
                av_fifo_free(ost->fifo); /* works even if fifo is not
                 initialized but set to zero */
                av_freep(&ost->st->codec->subtitle_header);
                av_free(ost->resample_frame.data[0]);
                av_free(ost->forced_kf_pts);
                if (ost->video_resample)
                    sws_freeContext(ost->img_resample_ctx);
                swr_free(&ost->swr);
                av_dict_free(&ost->opts);
            }
        }
    }
    return ret;
}

原文地址：http://blog.csdn.net/niu_gao/article/details/7175421