• ffmpeg 之ffmpeg 整理流程分析

    这个篇文档主要对ffmpeg  命令分析：主要分析ffmpeg 程序主要流程：

     1. 分析命令行函数，解析出输入文件及输出文件

     ffmpeg_parse_option 

    1. int ffmpeg_parse_options(int argc, char **argv)
    2. {
    3.     OptionParseContext octx;
    4.     uint8_t error[128];
    5.     int ret;
    6.  
    7.     memset(&octx, 0, sizeof(octx));
    8.  
    9.     /* split the commandline into an internal representation */
    10.     ret = split_commandline(&octx, argc, argv, options, groups,
    11.                             FF_ARRAY_ELEMS(groups));
    12.     if (ret < 0) {
    13.         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
    14.         goto fail;
    15.     }
    16.  
    17.     /* apply global options */
    18.     ret = parse_optgroup(NULL, &octx.global_opts);
    19.     if (ret < 0) {
    20.         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
    21.         goto fail;
    22.     }
    23.  
    24.     /* configure terminal and setup signal handlers */
    25.     term_init();
    26.  
    27.     /* open input files */
    28.     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
    29.     if (ret < 0) {
    30.         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
    31.         goto fail;
    32.     }
    33.  
    34.     /* create the complex filtergraphs */
    35.     ret = init_complex_filters();
    36.     if (ret < 0) {
    37.         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
    38.         goto fail;
    39.     }
    40.  
    41.     /* open output files */
    42.     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
    43.     if (ret < 0) {
    44.         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
    45.         goto fail;
    46.     }
    47.  
    48.     check_filter_outputs();
    49.  
    50. fail:
    51.     uninit_parse_context(&octx);
    52.     if (ret < 0) {
    53.         av_strerror(ret, error, sizeof(error));
    54.         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
    55.     }
    56.     return ret;
    57. }

    2. transcode 转码处理

    1. static int transcode(void)
    2. {
    3.     int ret, i;
    4.     AVFormatContext *os;
    5.     OutputStream *ost;
    6.     InputStream *ist;
    7.     int64_t timer_start;
    8.     int64_t total_packets_written = 0;
    9.  
    10.     ret = transcode_init();     // 转码初始化
    11.     if (ret < 0)
    12.         goto fail;
    13.  
    14.     if (stdin_interaction) {
    15.         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
    16.     }
    17.  
    18.     timer_start = av_gettime_relative();
    19.  
    20. #if HAVE_THREADS
    21.     if ((ret = init_input_threads()) < 0)
    22.         goto fail;
    23. #endif
    24.  
    25.     while (!received_sigterm) {
    26.         int64_t cur_time= av_gettime_relative();
    27.  
    28.         /* if 'q' pressed, exits */
    29.         if (stdin_interaction)
    30.             if (check_keyboard_interaction(cur_time) < 0)
    31.                 break;
    32.  
    33.         /* check if there's any stream where output is still needed */
    34.         if (!need_output()) {
    35.             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
    36.             break;
    37.         }
    38.  
    39.         ret = transcode_step();
    40.         if (ret < 0 && ret != AVERROR_EOF) {
    41.             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
    42.             break;
    43.         }
    44.  
    45.         /* dump report by using the output first video and audio streams */
    46.         print_report(0, timer_start, cur_time);
    47.     }
    48. #if HAVE_THREADS
    49.     free_input_threads();
    50. #endif
    51.  
    52.     /* at the end of stream, we must flush the decoder buffers */
    53.     for (i = 0; i < nb_input_streams; i++) {
    54.         ist = input_streams[i];
    55.         if (!input_files[ist->file_index]->eof_reached) {
    56.             process_input_packet(ist, NULL, 0);
    57.         }
    58.     }
    59.     flush_encoders();
    60.  
    61.     term_exit();
    62.  
    63.     /* write the trailer if needed and close file */
    64.     for (i = 0; i < nb_output_files; i++) {
    65.         os = output_files[i]->ctx;
    66.         if (!output_files[i]->header_written) {
    67.             av_log(NULL, AV_LOG_ERROR,
    68.                    "Nothing was written into output file %d (%s), because "
    69.                    "at least one of its streams received no packets.\n",
    70.                    i, os->url);
    71.             continue;
    72.         }
    73.         if ((ret = av_write_trailer(os)) < 0) {
    74.             av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s\n", os->url, av_err2str(ret));
    75.             if (exit_on_error)
    76.                 exit_program(1);
    77.         }
    78.     }
    79.  
    80.     /* dump report by using the first video and audio streams */
    81.     print_report(1, timer_start, av_gettime_relative());
    82.  
    83.     /* close each encoder */
    84.     for (i = 0; i < nb_output_streams; i++) {
    85.         ost = output_streams[i];
    86.         if (ost->encoding_needed) {
    87.             av_freep(&ost->enc_ctx->stats_in);
    88.         }
    89.         total_packets_written += ost->packets_written;
    90.         if (!ost->packets_written && (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM)) {
    91.             av_log(NULL, AV_LOG_FATAL, "Empty output on stream %d.\n", i);
    92.             exit_program(1);
    93.         }
    94.     }
    95.  
    96.     if (!total_packets_written && (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT)) {
    97.         av_log(NULL, AV_LOG_FATAL, "Empty output\n");
    98.         exit_program(1);
    99.     }
    100.  
    101.     /* close each decoder */
    102.     for (i = 0; i < nb_input_streams; i++) {
    103.         ist = input_streams[i];
    104.         if (ist->decoding_needed) {
    105.             avcodec_close(ist->dec_ctx);
    106.             if (ist->hwaccel_uninit)
    107.                 ist->hwaccel_uninit(ist->dec_ctx);
    108.         }
    109.     }
    110.  
    111.     hw_device_free_all();
    112.  
    113.     /* finished ! */
    114.     ret = 0;
    115.  
    116.  fail:
    117. #if HAVE_THREADS
    118.     free_input_threads();
    119. #endif
    120.  
    121.     if (output_streams) {
    122.         for (i = 0; i < nb_output_streams; i++) {
    123.             ost = output_streams[i];
    124.             if (ost) {
    125.                 if (ost->logfile) {
    126.                     if (fclose(ost->logfile))
    127.                         av_log(NULL, AV_LOG_ERROR,
    128.                                "Error closing logfile, loss of information possible: %s\n",
    129.                                av_err2str(AVERROR(errno)));
    130.                     ost->logfile = NULL;
    131.                 }
    132.                 av_freep(&ost->forced_kf_pts);
    133.                 av_freep(&ost->apad);
    134.                 av_freep(&ost->disposition);
    135.                 av_dict_free(&ost->encoder_opts);
    136.                 av_dict_free(&ost->sws_dict);
    137.                 av_dict_free(&ost->swr_opts);
    138.                 av_dict_free(&ost->resample_opts);
    139.             }
    140.         }
    141.     }
    142.     return ret;
    143. }

      2.1  transcode_step     // 转换流程。
                   process_input
                          process_input_packet

    1. /* pkt = NULL means EOF (needed to flush decoder buffers) */
    2. static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
    3. {
    4.     int ret = 0, i;
    5.     int repeating = 0;
    6.     int eof_reached = 0;
    7.  
    8.     AVPacket avpkt;
    9.     if (!ist->saw_first_ts) {
    10.         ist->dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
    11.         ist->pts = 0;
    12.         if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
    13.             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
    14.             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
    15.         }
    16.         ist->saw_first_ts = 1;
    17.     }
    18.  
    19.     if (ist->next_dts == AV_NOPTS_VALUE)
    20.         ist->next_dts = ist->dts;
    21.     if (ist->next_pts == AV_NOPTS_VALUE)
    22.         ist->next_pts = ist->pts;
    23.  
    24.     if (!pkt) {
    25.         /* EOF handling */
    26.         av_init_packet(&avpkt);
    27.         avpkt.data = NULL;
    28.         avpkt.size = 0;
    29.     } else {
    30.         avpkt = *pkt;
    31.     }
    32.  
    33.     if (pkt && pkt->dts != AV_NOPTS_VALUE) {
    34.         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
    35.         if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
    36.             ist->next_pts = ist->pts = ist->dts;
    37.     }
    38.  
    39.     // while we have more to decode or while the decoder did output something on EOF
    40.     while (ist->decoding_needed) {
    41.         int64_t duration_dts = 0;
    42.         int64_t duration_pts = 0;
    43.         int got_output = 0;
    44.         int decode_failed = 0;
    45.  
    46.         ist->pts = ist->next_pts;
    47.         ist->dts = ist->next_dts;
    48.  
    49.         switch (ist->dec_ctx->codec_type) {
    50.         case AVMEDIA_TYPE_AUDIO:
    51.             ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
    52.                                    &decode_failed);
    53.             break;
    54.         case AVMEDIA_TYPE_VIDEO:
    55.             ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, &duration_pts, !pkt,
    56.                                    &decode_failed);
    57.             if (!repeating || !pkt || got_output) {
    58.                 if (pkt && pkt->duration) {
    59.                     duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
    60.                 } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
    61.                     int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
    62.                     duration_dts = ((int64_t)AV_TIME_BASE *
    63.                                     ist->dec_ctx->framerate.den * ticks) /
    64.                                     ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
    65.                 }
    66.  
    67.                 if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
    68.                     ist->next_dts += duration_dts;
    69.                 }else
    70.                     ist->next_dts = AV_NOPTS_VALUE;
    71.             }
    72.  
    73.             if (got_output) {
    74.                 if (duration_pts > 0) {
    75.                     ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
    76.                 } else {
    77.                     ist->next_pts += duration_dts;
    78.                 }
    79.             }
    80.             break;
    81.         case AVMEDIA_TYPE_SUBTITLE:
    82.             if (repeating)
    83.                 break;
    84.             ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
    85.             if (!pkt && ret >= 0)
    86.                 ret = AVERROR_EOF;
    87.             break;
    88.         default:
    89.             return -1;
    90.         }
    91.  
    92.         if (ret == AVERROR_EOF) {
    93.             eof_reached = 1;
    94.             break;
    95.         }
    96.  
    97.         if (ret < 0) {
    98.             if (decode_failed) {
    99.                 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
    100.                        ist->file_index, ist->st->index, av_err2str(ret));
    101.             } else {
    102.                 av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
    103.                        "data for stream #%d:%d\n", ist->file_index, ist->st->index);
    104.             }
    105.             if (!decode_failed || exit_on_error)
    106.                 exit_program(1);
    107.             break;
    108.         }
    109.  
    110.         if (got_output)
    111.             ist->got_output = 1;
    112.  
    113.         if (!got_output)
    114.             break;
    115.  
    116.         // During draining, we might get multiple output frames in this loop.
    117.         // ffmpeg.c does not drain the filter chain on configuration changes,
    118.         // which means if we send multiple frames at once to the filters, and
    119.         // one of those frames changes configuration, the buffered frames will
    120.         // be lost. This can upset certain FATE tests.
    121.         // Decode only 1 frame per call on EOF to appease these FATE tests.
    122.         // The ideal solution would be to rewrite decoding to use the new
    123.         // decoding API in a better way.
    124.         if (!pkt)
    125.             break;
    126.  
    127.         repeating = 1;
    128.     }
    129.  
    130.     /* after flushing, send an EOF on all the filter inputs attached to the stream */
    131.     /* except when looping we need to flush but not to send an EOF */
    132.     if (!pkt && ist->decoding_needed && eof_reached && !no_eof) {
    133.         int ret = send_filter_eof(ist);
    134.         if (ret < 0) {
    135.             av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
    136.             exit_program(1);
    137.         }
    138.     }
    139.  
    140.     /* handle stream copy */
    141.     if (!ist->decoding_needed && pkt) {
    142.         ist->dts = ist->next_dts;
    143.         switch (ist->dec_ctx->codec_type) {
    144.         case AVMEDIA_TYPE_AUDIO:
    145.             av_assert1(pkt->duration >= 0);
    146.             if (ist->dec_ctx->sample_rate) {
    147.                 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
    148.                                   ist->dec_ctx->sample_rate;
    149.             } else {
    150.                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
    151.             }
    152.             break;
    153.         case AVMEDIA_TYPE_VIDEO:
    154.             if (ist->framerate.num) {
    155.                 // TODO: Remove work-around for c99-to-c89 issue 7
    156.                 AVRational time_base_q = AV_TIME_BASE_Q;
    157.                 int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
    158.                 ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
    159.             } else if (pkt->duration) {
    160.                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
    161.             } else if(ist->dec_ctx->framerate.num != 0) {
    162.                 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
    163.                 ist->next_dts += ((int64_t)AV_TIME_BASE *
    164.                                   ist->dec_ctx->framerate.den * ticks) /
    165.                                   ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
    166.             }
    167.             break;
    168.         }
    169.         ist->pts = ist->dts;
    170.         ist->next_pts = ist->next_dts;
    171.     }
    172.     for (i = 0; i < nb_output_streams; i++) {
    173.         OutputStream *ost = output_streams[i];
    174.  
    175.         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
    176.             continue;
    177.  
    178.         do_streamcopy(ist, ost, pkt);  // packet 拷贝到输出文件
    179.     }
    180.  
    181.     return !eof_reached;
    182. }

     3. do_streamcopy

    do_streamcopy
        output_packet
            write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
                av_interleaved_write_frame
                    write_packets_common
                        write_packet(AVFormatContext *s, AVPacket *pkt)
                            s->oformat->write_packet
                                 AVOutputFormat *oformat; mux  中函数：                

  • 相关阅读:
    学习笔记：SpringCloud 微服务技术栈_高级篇⑤_可靠消息服务
    mysql高阶sql语句
    仿京东放大镜效果（pink老师版）
    抖音聊天对话模板，制作一条一条冒出来的聊天对话短视频
    NVIDIA 7th SkyHackathon（七）Tao 目标检测模型可视化推理与导出
    ROS2-IRON Ubuntu-22.0 源码下载失败解决方法 vcs import --input
    Node 版本切换
    RHCE8 资料整理（七）
    高并发系统架构设计之实战篇：信息流设计之推模式
    系统移植 串口输入ECHO点灯
  • 原文地址：https://blog.csdn.net/u012794472/article/details/126748768