• Android 使用FFmpeg3.3.9基于命令实现视频压缩

    前言

    首先利用linux平台编译ffmpeg的so库，具体详情请查看文章：Android NDK(ndk-r16b)交叉编译FFmpeg(3.3.9)_jszlittlecat_720的博客-CSDN博客

    1.创建VideoCompress类

     

    1. package com.suoer.ndk.ffmpegtestapplication;
    2.  
    3. public class VideoCompress {
    4.     /**
    5.      * compressVideo native 方法
    6.      * @param compressCommand 压缩命令
    7.      * @param callback        压缩回调
    8.      */
    9.     public native void compressVideo(String[] compressCommand,CompressCallback callback);
    10.     //CompressCallback 压缩回调
    11.     public interface CompressCallback{
    12.         /**
    13.          * onCompress
    14.          * @param current 压缩的当前进度
    15.          * @param total   总进度
    16.          */
    17.         public void onCompress(int current,int total);
    18.     }
    19. }
    compressVideo报红，鼠标停在上面，左边会出现红色小灯泡，点击红色小灯泡

     点击Create JNI function for compressVideo

    自动打开native-lib.cpp并创建完成Java_com_suoer_ndk_ffmpegtestapplication_VideoCompress_compressVideo 方法

     在此方法下实现压缩视频

    2.MainActivity实现点击TextView实现压缩视频

    2.1权限问题处理

    压缩视频需要读写文件的权限

    打开AndroidManifest.xml

    添加读写文件权限

    1.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE">uses-permission>
    2.     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE">uses-permission>

     权限处理使用rxpermissions

    rxpermissions github地址：GitHub - tbruyelle/RxPermissions: Android runtime permissions powered by RxJava2

    rxpermissions使用方式

    打开项目下的build.gradle添加如下代码：

    maven { url 'https://jitpack.io' }

     打开app下的build.gradle添加如下代码：

    implementation 'com.github.tbruyelle:rxpermissions:0.12'

     点击同步按钮，同步文件

     2.2子线程处理耗时操作

    压缩视频是耗时操作，子线程处理耗时操作。

    使用rxandroid实现子线程耗时操作并实现子线程和主线程切换

    rxandroid github地址：GitHub - ReactiveX/RxAndroid: RxJava bindings for Android

     rxandroid使用方式：

    打开项目下的build.gradle添加如下代码：

    maven { url "https://oss.jfrog.org/libs-snapshot" }

     打开app下的build.gradle添加如下代码：

    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'

     点击同步按钮同步文件

    MainActivity.java内容如下：

    1. package com.suoer.ndk.ffmpegtestapplication;
    2.  
    3. import android.Manifest;
    4. import android.os.Bundle;
    5. import android.os.Environment;
    6. import android.util.Log;
    7. import android.view.View;
    8. import android.widget.TextView;
    9.  
    10. import com.tbruyelle.rxpermissions3.RxPermissions;
    11.  
    12. import java.io.File;
    13.  
    14. import androidx.appcompat.app.AppCompatActivity;
    15. import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
    16. import io.reactivex.rxjava3.core.Observable;
    17. import io.reactivex.rxjava3.functions.Consumer;
    18. import io.reactivex.rxjava3.functions.Function;
    19. import io.reactivex.rxjava3.schedulers.Schedulers;
    20.  
    21. public class MainActivity extends AppCompatActivity {
    22.     private File mInFile=new File(Environment.getExternalStorageDirectory(),"test.mp4");//mInFile 需要压缩的文件路径
    23.     private File mOutFile=new File(Environment.getExternalStorageDirectory(),"out.mp4");//mOutFile压缩后的文件路径
    24.     // Used to load the 'native-lib' library on application startup.
    25.     static {
    26.         System.loadLibrary("native-lib");
    27.     }
    28.  
    29.     @Override
    30.     protected void onCreate(Bundle savedInstanceState) {
    31.         super.onCreate(savedInstanceState);
    32.         setContentView(R.layout.activity_main);
    33.  
    34.         // Example of a call to a native method
    35.         TextView tv = findViewById(R.id.sample_text);
    36.         //tv.setText("ffmpeg版本："+stringFromJNI());
    37.         tv.setText("压缩");
    38.  
    39.         //tv的点击事件 点击按钮实现视频压缩
    40.         tv.setOnClickListener(new View.OnClickListener() {
    41.             @Override
    42.             public void onClick(View v) {
    43.                 // 压缩文件 需要读写文件权限 申请权限
    44.                 RxPermissions rxPermissions=new RxPermissions(MainActivity.this);
    45.                 rxPermissions.request(Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE).subscribe(new Consumer() {
    46.             @Override
    47.             public void accept(Boolean aBoolean) throws Throwable {
    48.                 if(aBoolean){
    49.                     //权限已经获取 压缩视频
    50.                     compressVideo();
    51.                 }
    52.             }
    53.         });
    54.             }
    55.         });
    56.     }
    57.  
    58.     /**
    59.      * 开启子线程处理耗时压缩问题
    60.      */
    61.  
    62.     private void compressVideo() {
    63.         //ffmpeg的压缩命令:ffmpeg -i test.mp4 -b:v 1024k out.mp4
    64.         //ffmpeg -i test.mp4 -b:v 1024k out.mp4
    65.         //-b:v 1024k 1024k为码率 码率越高视频越清晰，而且视频越大
    66.         //test.mp4需要压缩的文件
    67.         //out.mp4 压缩之后的文件
    68.  
    69.         String[] compressCommand={"ffmpeg","-i",mInFile.getAbsolutePath(),"-b:v","1024k",mOutFile.getAbsolutePath()};
    70.         //压缩是耗时的，需要子线程处理
    71.         Observable.just(compressCommand).map(new Function() {
    72.             @Override
    73.             public File apply(String[] compressCommand) throws Throwable {
    74.                 VideoCompress videoCompress=new VideoCompress();
    75.                 videoCompress.compressVideo(compressCommand, new VideoCompress.CompressCallback() {
    76.                     @Override
    77.                     public void onCompress(int current, int total) {
    78.                         Log.e("TAG", "onCompress: 压缩进度:"+current+"/"+total);
    79.  
    80.                     }
    81.                 });
    82.                 return mOutFile;
    83.             }
    84.         }).subscribeOn(Schedulers.io())
    85.         .observeOn(AndroidSchedulers.mainThread())
    86.         .subscribe(new Consumer() {
    87.             @Override
    88.             public void accept(File file) throws Throwable {
    89.                 //压缩完成
    90.                 Log.e("TAG", "accept: 压缩完成！" );
    91.             }
    92.         });
    93.  
    94.  
    95.     }
    96.  
    97.  
    98.  
    99.     /**
    100.      * A native method that is implemented by the 'native-lib' native library,
    101.      * which is packaged with this application.
    102.      */
    103.     public native String stringFromJNI();
    104. }

    3.拷贝视频压缩使用命令实现需要的其他文件

    include目录下创建compat文件夹把所需要的头文件 os2threads.h va_copy.h w32pthreads.h拷贝此文件夹中

    这三个头文件存在于下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9的compat文件夹中

     在jniLibs文件夹中创建other文件夹

     拷贝linux平台编译后的文件cmdutils.h cmdutils_common_opts.h config.h ffmpeg.h 拷贝至other文件夹中

     

     将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中的cmdutils.c 

    ffmpeg.c ffmpeg_filter.c ffmpeg_opt.c 四个文件拷贝至cpp文件夹中

     

     配置CMakeLists.txt文件修改如下内容

     CMakeLists.txt内容如下：

    1. # For more information about using CMake with Android Studio, read the
    2. # documentation: https://d.android.com/studio/projects/add-native-code.html
    3.  
    4. # Sets the minimum version of CMake required to build the native library.
    5.  
    6. cmake_minimum_required(VERSION 3.10.2)
    7.  
    8. # Declares and names the project.
    9.  
    10. project("ffmpegtestapplication")
    11.  
    12. #判断编译器类型,如果是gcc编译器,则在编译选项中加入c++11支持
    13. if(CMAKE_COMPILER_IS_GNUCXX)
    14.  
    15.     set(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
    16.     message(STATUS "optional:-std=c++11")
    17. endif(CMAKE_COMPILER_IS_GNUCXX)
    18.  
    19.  
    20. #需要引入我们头文件，以这个配置的目录为基准
    21.  
    22. include_directories(${CMAKE_SOURCE_DIR}/../jniLibs/include)
    23. include_directories(${CMAKE_SOURCE_DIR}/../jniLibs/other)
    24.  
    25. # Creates and names a library, sets it as either STATIC
    26. # or SHARED, and provides the relative paths to its source code.
    27. # You can define multiple libraries, and CMake builds them for you.
    28. # Gradle automatically packages shared libraries with your APK.
    29.  
    30. add_library( # Sets the name of the library.
    31.              native-lib
    32.  
    33.              # Sets the library as a shared library.
    34.              SHARED
    35.  
    36.              # Provides a relative path to your source file(s).
    37.              native-lib.cpp
    38.              #添加额外的c文件
    39.              cmdutils.c
    40.              ffmpeg.c
    41.              ffmpeg_filter.c
    42.              ffmpeg_opt.c
    43.  
    44.         )
    45. # 编解码(最重要的库)
    46. add_library(
    47.         avcodec
    48.         SHARED
    49.         IMPORTED)
    50. set_target_properties(
    51.         avcodec
    52.         PROPERTIES IMPORTED_LOCATION
    53.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libavcodec-57.so)
    54.  
    55. # 设备信息
    56. add_library(
    57.         avdevice
    58.         SHARED
    59.         IMPORTED)
    60. set_target_properties(
    61.         avdevice
    62.         PROPERTIES IMPORTED_LOCATION
    63.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libavdevice-57.so)
    64.  
    65. # 滤镜特效处理库
    66. add_library(
    67.         avfilter
    68.         SHARED
    69.         IMPORTED)
    70. set_target_properties(
    71.         avfilter
    72.         PROPERTIES IMPORTED_LOCATION
    73.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libavfilter-6.so)
    74.  
    75. # 封装格式处理库
    76. add_library(
    77.         avformat
    78.         SHARED
    79.         IMPORTED)
    80. set_target_properties(
    81.         avformat
    82.         PROPERTIES IMPORTED_LOCATION
    83.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libavformat-57.so)
    84. # 重采样处理库
    85. add_library(
    86.         avresample
    87.         SHARED
    88.         IMPORTED)
    89. set_target_properties(
    90.         avresample
    91.         PROPERTIES IMPORTED_LOCATION
    92.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libavresample-3.so)
    93. # 工具库(大部分库都需要这个库的支持)
    94. add_library(
    95.         avutil
    96.         SHARED
    97.         IMPORTED)
    98. set_target_properties(
    99.         avutil
    100.         PROPERTIES IMPORTED_LOCATION
    101.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libavutil-55.so)
    102.  
    103. # 后期处理
    104. add_library(
    105.         postproc
    106.         SHARED
    107.         IMPORTED)
    108. set_target_properties(
    109.         postproc
    110.         PROPERTIES IMPORTED_LOCATION
    111.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libpostproc-54.so)
    112.  
    113. # 音频采样数据格式转换库
    114. add_library(
    115.         swresample
    116.         SHARED
    117.         IMPORTED)
    118. set_target_properties(
    119.         swresample
    120.         PROPERTIES IMPORTED_LOCATION
    121.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libswresample-2.so)
    122.  
    123. # 视频像素数据格式转换
    124. add_library(
    125.         swscale
    126.         SHARED
    127.         IMPORTED)
    128. set_target_properties(
    129.         swscale
    130.         PROPERTIES IMPORTED_LOCATION
    131.         ${CMAKE_SOURCE_DIR}/../jniLibs/armeabi-v7a/libswscale-4.so)
    132.  
    133. # Searches for a specified prebuilt library and stores the path as a
    134. # variable. Because CMake includes system libraries in the search path by
    135. # default, you only need to specify the name of the public NDK library
    136. # you want to add. CMake verifies that the library exists before
    137. # completing its build.
    138.  
    139. find_library( # Sets the name of the path variable.
    140.               log-lib
    141.  
    142.               # Specifies the name of the NDK library that
    143.               # you want CMake to locate.
    144.               log )
    145.  
    146. # Specifies libraries CMake should link to your target library. You
    147. # can link multiple libraries, such as libraries you define in this
    148. # build script, prebuilt third-party libraries, or system libraries.
    149.  
    150. target_link_libraries( # Specifies the target library.
    151.                        native-lib avcodec avdevice avfilter avformat avresample avutil postproc swresample swscale
    152.  
    153.                        # Links the target library to the log library
    154.                        # included in the NDK.
    155.                        ${log-lib} )

    运行Run app至手机设备，出现如下如所示错误

     D:\suowei\androidproject\FFmpegTestApplication\app\src\main\cpp\cmdutils.c:47:10: fatal error: 'libavutil/libm.h' file not found

    解决方式：将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavutil中的libm.h拷贝至android项目jniLibs下的libavutil中

     

     D:\suowei\androidproject\FFmpegTestApplication\app\src\main\cpp\ffmpeg.c:52:10: fatal error: 'libavutil/internal.h' file not found

     解决方式：将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavutil中的internal.h拷贝至android项目jniLibs下的libavutil中

     

     重新Run app至手机设备，出现如下图所示错误

     D:\suowei\androidproject\FFmpegTestApplication\app\src\main\cpp\cmdutils.c:58:10: fatal error: 'libavformat/network.h' file not found

    解决方式：将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavformat中的network.h拷贝至android项目jniLibs下的libavformat中

     

     D:\suowei\androidproject\FFmpegTestApplication\app\src\main\jniLibs\include\libavutil\internal.h:42:10: fatal error: 'timer.h' file not found

     解决方式：将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavutil中的timer.h拷贝至android项目jniLibs下的libavutil中

     

     

     重新Run app至手机设备，出现如下图所示错误

     D:/suowei/androidproject/FFmpegTestApplication/app/src/main/cpp/../jniLibs/include\libavformat/network.h:29:10: fatal error: 'os_support.h' file not found
    #include "os_support.h"

      解决方式：将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavformat中的os_support.h拷贝至android项目jniLibs下的libavformat中

     

     D:/suowei/androidproject/FFmpegTestApplication/app/src/main/cpp/../jniLibs/include\libavutil/timer.h:44:13: fatal error: 'arm/timer.h' file not found

    解决方式：android项目jniLibs目录下的libavutil文件夹下创建arm文件夹

     将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavutil中的arm文件夹下的timer.h拷贝至android项目jniLibs下的libavutil中的arm文件夹下

     

     重新Run app至手机设备，出现如下图所示错误

     D:/suowei/androidproject/FFmpegTestApplication/app/src/main/cpp/ffmpeg.c:65:10: fatal error: 'libavcodec/mathops.h' file not found

    解决方式：将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavcodec中的mathops.h拷贝至android项目jniLibs下的libavcodec中

     

     重新Run app至手机设备，出现如下图所示错误

     D:/suowei/androidproject/FFmpegTestApplication/app/src/main/cpp/../jniLibs/include\libavformat/network.h:31:10: fatal error: 'url.h' file not found

    解决方式：将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavformat中的url.h拷贝至android项目jniLibs下的libavformat中

     D:/suowei/androidproject/FFmpegTestApplication/app/src/main/cpp/../jniLibs/include\libavcodec/mathops.h:28:10: fatal error: 'libavutil/reverse.h' file not found

    解决方式：将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavutil中的reverse.h拷贝至android项目jniLibs下的libavutil中

     

     

     重新Run app至手机设备，出现如下图所示错误

     D:/suowei/androidproject/FFmpegTestApplication/app/src/main/cpp/../jniLibs/include\libavcodec/mathops.h:40:13: fatal error: 'arm/mathops.h' file not found

    解决方式：android项目jniLibs目录下的libavcodec文件夹下创建arm文件夹

     

     将下载之后的ffmpeg-3.3.9.tar.gz解压之后的文件夹ffmpeg-3.3.9中libavcodec中的arm文件夹下的mathops.h拷贝至android项目jniLibs下的libavcodec中的arm文件夹下

     

     重新Run app至手机设备，android项目运行成功。

    4.编写native-cpp实现视频压缩

     

    修改ffmpeg.c，找到main方法修改方法名称为：run_ffmpeg_command 并注释掉此行代码

    exit_program(received_nb_signals ? 255 : main_return_code);

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

    native-lib.cpp代码如下：

    1. #include 
    2. #include 
    3. #include 
    4. #define TAG "JNI_TAG"
    5. #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,TAG,__VA_ARGS__);
    6. extern "C" {
    7. #include "libavutil/avutil.h"
    8.     //声明方法 argc命令的个数  argv 二维数组
    9. int run_ffmpeg_command(int argc, char **argv);
    10. }
    11. extern "C" JNIEXPORT jstring JNICALL
    12. Java_com_suoer_ndk_ffmpegtestapplication_MainActivity_stringFromJNI(
    13.         JNIEnv* env,
    14.         jobject /* this */) {
    15.     //std::string hello = "Hello from C++";
    16.     return env->NewStringUTF(av_version_info());
    17. }extern "C"
    18. JNIEXPORT void JNICALL
    19. Java_com_suoer_ndk_ffmpegtestapplication_VideoCompress_compressVideo(JNIEnv *env, jobject thiz,
    20.                                                                      jobjectArray compress_command,
    21.                                                                      jobject callback) {
    22.     //ffmpeg 处理视频压缩
    23.     //arm这个里面的so都是用来处理音视频的，include都是头文件
    24.     //还有几个没有被打包编译成so,因为这些不算是音视频的处理代码，只是我们现在支持命令(封装)
    25.     //1.获取命令个数
    26.     int argc=env->GetArrayLength(compress_command);
    27.     //2.给char **argv填充数据
    28.     char **argv=(char **)malloc(sizeof(char*)*argc);
    29.     for (int i = 0; i 
    30.         jstring  j_param=(jstring)env->GetObjectArrayElement(compress_command,i);
    31.         argv[i]= (char *)(env->GetStringUTFChars(j_param, NULL));
    32.         LOGE("参数：%s",argv[i]);
    33.     }
    34.     //3.调用命令函数去压缩
    35.      run_ffmpeg_command(argc,argv);
    36.     //4.释放内存
    37.     for (int i = 0; i 
    38.         free(argv[i]);
    39.     }
    40.     free(argv);
    41. }

    视频压缩回调处理，视频压缩进度回调

    修改ffmpeg.c内容如下：

    print_report方法

     

     transcode方法

     

     

     run_ffmpeg_command方法

     

     

     ffmpeg.c内容如下：

    1. /*
    2.  * Copyright (c) 2000-2003 Fabrice Bellard
    3.  *
    4.  * This file is part of FFmpeg.
    5.  *
    6.  * FFmpeg is free software; you can redistribute it and/or
    7.  * modify it under the terms of the GNU Lesser General Public
    8.  * License as published by the Free Software Foundation; either
    9.  * version 2.1 of the License, or (at your option) any later version.
    10.  *
    11.  * FFmpeg is distributed in the hope that it will be useful,
    12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    14.  * Lesser General Public License for more details.
    15.  *
    16.  * You should have received a copy of the GNU Lesser General Public
    17.  * License along with FFmpeg; if not, write to the Free Software
    18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    19.  */
    20.  
    21. /**
    22.  * @file
    23.  * multimedia converter based on the FFmpeg libraries
    24.  */
    25.  
    26. #include "config.h"
    27. #include 
    28. #include 
    29. #include 
    30. #include 
    31. #include 
    32. #include 
    33. #include 
    34. #include 
    35.  
    36. #if HAVE_IO_H
    37. #include 
    38. #endif
    39. #if HAVE_UNISTD_H
    40. #include 
    41. #endif
    42.  
    43. #include "libavformat/avformat.h"
    44. #include "libavdevice/avdevice.h"
    45. #include "libswresample/swresample.h"
    46. #include "libavutil/opt.h"
    47. #include "libavutil/channel_layout.h"
    48. #include "libavutil/parseutils.h"
    49. #include "libavutil/samplefmt.h"
    50. #include "libavutil/fifo.h"
    51. #include "libavutil/hwcontext.h"
    52. #include "libavutil/internal.h"
    53. #include "libavutil/intreadwrite.h"
    54. #include "libavutil/dict.h"
    55. #include "libavutil/display.h"
    56. #include "libavutil/mathematics.h"
    57. #include "libavutil/pixdesc.h"
    58. #include "libavutil/avstring.h"
    59. #include "libavutil/libm.h"
    60. #include "libavutil/imgutils.h"
    61. #include "libavutil/timestamp.h"
    62. #include "libavutil/bprint.h"
    63. #include "libavutil/time.h"
    64. #include "libavutil/threadmessage.h"
    65. #include "libavcodec/mathops.h"
    66. #include "libavformat/os_support.h"
    67.  
    68. # include "libavfilter/avfilter.h"
    69. # include "libavfilter/buffersrc.h"
    70. # include "libavfilter/buffersink.h"
    71.  
    72. #if HAVE_SYS_RESOURCE_H
    73. #include 
    74. #include 
    75. #include 
    76. #elif HAVE_GETPROCESSTIMES
    77. #include 
    78. #endif
    79. #if HAVE_GETPROCESSMEMORYINFO
    80. #include 
    81. #include 
    82. #endif
    83. #if HAVE_SETCONSOLECTRLHANDLER
    84. #include 
    85. #endif
    86.  
    87.  
    88. #if HAVE_SYS_SELECT_H
    89. #include 
    90. #endif
    91.  
    92. #if HAVE_TERMIOS_H
    93. #include 
    94. #include 
    95. #include 
    96. #include 
    97. #elif HAVE_KBHIT
    98. #include 
    99. #endif
    100.  
    101. #if HAVE_PTHREADS
    102. #include 
    103. #endif
    104.  
    105. #include 
    106. #include 
    107.  
    108. #include "ffmpeg.h"
    109. #include "cmdutils.h"
    110.  
    111. #include "libavutil/avassert.h"
    112.  
    113. const char program_name[] = "ffmpeg";
    114. const int program_birth_year = 2000;
    115.  
    116. static FILE *vstats_file;
    117.  
    118. const char *const forced_keyframes_const_names[] = {
    119.     "n",
    120.     "n_forced",
    121.     "prev_forced_n",
    122.     "prev_forced_t",
    123.     "t",
    124.     NULL
    125. };
    126.  
    127. static void do_video_stats(OutputStream *ost, int frame_size);
    128. static int64_t getutime(void);
    129. static int64_t getmaxrss(void);
    130. static int ifilter_has_all_input_formats(FilterGraph *fg);
    131.  
    132. static int run_as_daemon  = 0;
    133. static int nb_frames_dup = 0;
    134. static unsigned dup_warning = 1000;
    135. static int nb_frames_drop = 0;
    136. static int64_t decode_error_stat[2];
    137.  
    138. static int want_sdp = 1;
    139.  
    140. static int current_time;
    141. AVIOContext *progress_avio = NULL;
    142.  
    143. static uint8_t *subtitle_out;
    144.  
    145. InputStream **input_streams = NULL;
    146. int        nb_input_streams = 0;
    147. InputFile   **input_files   = NULL;
    148. int        nb_input_files   = 0;
    149.  
    150. OutputStream **output_streams = NULL;
    151. int         nb_output_streams = 0;
    152. OutputFile   **output_files   = NULL;
    153. int         nb_output_files   = 0;
    154.  
    155. FilterGraph **filtergraphs;
    156. int        nb_filtergraphs;
    157.  
    158. #if HAVE_TERMIOS_H
    159.  
    160. /* init terminal so that we can grab keys */
    161. static struct termios oldtty;
    162. static int restore_tty;
    163. #endif
    164.  
    165. #if HAVE_PTHREADS
    166. static void free_input_threads(void);
    167. #endif
    168.  
    169. /* sub2video hack:
    170.    Convert subtitles to video with alpha to insert them in filter graphs.
    171.    This is a temporary solution until libavfilter gets real subtitles support.
    172.  */
    173.  
    174. static int sub2video_get_blank_frame(InputStream *ist)
    175. {
    176.     int ret;
    177.     AVFrame *frame = ist->sub2video.frame;
    178.  
    179.     av_frame_unref(frame);
    180.     ist->sub2video.frame->width  = ist->dec_ctx->width  ? ist->dec_ctx->width  : ist->sub2video.w;
    181.     ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
    182.     ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
    183.     if ((ret = av_frame_get_buffer(frame, 32)) < 0)
    184.         return ret;
    185.     memset(frame->data[0], 0, frame->height * frame->linesize[0]);
    186.     return 0;
    187. }
    188.  
    189. static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
    190.                                 AVSubtitleRect *r)
    191. {
    192.     uint32_t *pal, *dst2;
    193.     uint8_t *src, *src2;
    194.     int x, y;
    195.  
    196.     if (r->type != SUBTITLE_BITMAP) {
    197.         av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
    198.         return;
    199.     }
    200.     if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {
    201.         av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle (%d %d %d %d) overflowing %d %d\n",
    202.             r->x, r->y, r->w, r->h, w, h
    203.         );
    204.         return;
    205.     }
    206.  
    207.     dst += r->y * dst_linesize + r->x * 4;
    208.     src = r->data[0];
    209.     pal = (uint32_t *)r->data[1];
    210.     for (y = 0; y < r->h; y++) {
    211.         dst2 = (uint32_t *)dst;
    212.         src2 = src;
    213.         for (x = 0; x < r->w; x++)
    214.             *(dst2++) = pal[*(src2++)];
    215.         dst += dst_linesize;
    216.         src += r->linesize[0];
    217.     }
    218. }
    219.  
    220. static void sub2video_push_ref(InputStream *ist, int64_t pts)
    221. {
    222.     AVFrame *frame = ist->sub2video.frame;
    223.     int i;
    224.  
    225.     av_assert1(frame->data[0]);
    226.     ist->sub2video.last_pts = frame->pts = pts;
    227.     for (i = 0; i < ist->nb_filters; i++)
    228.         av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
    229.                                      AV_BUFFERSRC_FLAG_KEEP_REF |
    230.                                      AV_BUFFERSRC_FLAG_PUSH);
    231. }
    232.  
    233. void sub2video_update(InputStream *ist, AVSubtitle *sub)
    234. {
    235.     AVFrame *frame = ist->sub2video.frame;
    236.     int8_t *dst;
    237.     int     dst_linesize;
    238.     int num_rects, i;
    239.     int64_t pts, end_pts;
    240.  
    241.     if (!frame)
    242.         return;
    243.     if (sub) {
    244.         pts       = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
    245.                                  AV_TIME_BASE_Q, ist->st->time_base);
    246.         end_pts   = av_rescale_q(sub->pts + sub->end_display_time   * 1000LL,
    247.                                  AV_TIME_BASE_Q, ist->st->time_base);
    248.         num_rects = sub->num_rects;
    249.     } else {
    250.         pts       = ist->sub2video.end_pts;
    251.         end_pts   = INT64_MAX;
    252.         num_rects = 0;
    253.     }
    254.     if (sub2video_get_blank_frame(ist) < 0) {
    255.         av_log(ist->dec_ctx, AV_LOG_ERROR,
    256.                "Impossible to get a blank canvas.\n");
    257.         return;
    258.     }
    259.     dst          = frame->data    [0];
    260.     dst_linesize = frame->linesize[0];
    261.     for (i = 0; i < num_rects; i++)
    262.         sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
    263.     sub2video_push_ref(ist, pts);
    264.     ist->sub2video.end_pts = end_pts;
    265. }
    266.  
    267. static void sub2video_heartbeat(InputStream *ist, int64_t pts)
    268. {
    269.     InputFile *infile = input_files[ist->file_index];
    270.     int i, j, nb_reqs;
    271.     int64_t pts2;
    272.  
    273.     /* When a frame is read from a file, examine all sub2video streams in
    274.        the same file and send the sub2video frame again. Otherwise, decoded
    275.        video frames could be accumulating in the filter graph while a filter
    276.        (possibly overlay) is desperately waiting for a subtitle frame. */
    277.     for (i = 0; i < infile->nb_streams; i++) {
    278.         InputStream *ist2 = input_streams[infile->ist_index + i];
    279.         if (!ist2->sub2video.frame)
    280.             continue;
    281.         /* subtitles seem to be usually muxed ahead of other streams;
    282.            if not, subtracting a larger time here is necessary */
    283.         pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
    284.         /* do not send the heartbeat frame if the subtitle is already ahead */
    285.         if (pts2 <= ist2->sub2video.last_pts)
    286.             continue;
    287.         if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])
    288.             sub2video_update(ist2, NULL);
    289.         for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
    290.             nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
    291.         if (nb_reqs)
    292.             sub2video_push_ref(ist2, pts2);
    293.     }
    294. }
    295.  
    296. static void sub2video_flush(InputStream *ist)
    297. {
    298.     int i;
    299.  
    300.     if (ist->sub2video.end_pts < INT64_MAX)
    301.         sub2video_update(ist, NULL);
    302.     for (i = 0; i < ist->nb_filters; i++)
    303.         av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
    304. }
    305.  
    306. /* end of sub2video hack */
    307.  
    308. static void term_exit_sigsafe(void)
    309. {
    310. #if HAVE_TERMIOS_H
    311.     if(restore_tty)
    312.         tcsetattr (0, TCSANOW, &oldtty);
    313. #endif
    314. }
    315.  
    316. void term_exit(void)
    317. {
    318.     av_log(NULL, AV_LOG_QUIET, "%s", "");
    319.     term_exit_sigsafe();
    320. }
    321.  
    322. static volatile int received_sigterm = 0;
    323. static volatile int received_nb_signals = 0;
    324. static atomic_int transcode_init_done = ATOMIC_VAR_INIT(0);
    325. static volatile int ffmpeg_exited = 0;
    326. static int main_return_code = 0;
    327.  
    328. static void
    329. sigterm_handler(int sig)
    330. {
    331.     received_sigterm = sig;
    332.     received_nb_signals++;
    333.     term_exit_sigsafe();
    334.     if(received_nb_signals > 3) {
    335.         write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
    336.                            strlen("Received > 3 system signals, hard exiting\n"));
    337.  
    338.         exit(123);
    339.     }
    340. }
    341.  
    342. #if HAVE_SETCONSOLECTRLHANDLER
    343. static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
    344. {
    345.     av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
    346.  
    347.     switch (fdwCtrlType)
    348.     {
    349.     case CTRL_C_EVENT:
    350.     case CTRL_BREAK_EVENT:
    351.         sigterm_handler(SIGINT);
    352.         return TRUE;
    353.  
    354.     case CTRL_CLOSE_EVENT:
    355.     case CTRL_LOGOFF_EVENT:
    356.     case CTRL_SHUTDOWN_EVENT:
    357.         sigterm_handler(SIGTERM);
    358.         /* Basically, with these 3 events, when we return from this method the
    359.            process is hard terminated, so stall as long as we need to
    360.            to try and let the main thread(s) clean up and gracefully terminate
    361.            (we have at most 5 seconds, but should be done far before that). */
    362.         while (!ffmpeg_exited) {
    363.             Sleep(0);
    364.         }
    365.         return TRUE;
    366.  
    367.     default:
    368.         av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
    369.         return FALSE;
    370.     }
    371. }
    372. #endif
    373.  
    374. void term_init(void)
    375. {
    376. #if HAVE_TERMIOS_H
    377.     if (!run_as_daemon && stdin_interaction) {
    378.         struct termios tty;
    379.         if (tcgetattr (0, &tty) == 0) {
    380.             oldtty = tty;
    381.             restore_tty = 1;
    382.  
    383.             tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
    384.                              |INLCR|IGNCR|ICRNL|IXON);
    385.             tty.c_oflag |= OPOST;
    386.             tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
    387.             tty.c_cflag &= ~(CSIZE|PARENB);
    388.             tty.c_cflag |= CS8;
    389.             tty.c_cc[VMIN] = 1;
    390.             tty.c_cc[VTIME] = 0;
    391.  
    392.             tcsetattr (0, TCSANOW, &tty);
    393.         }
    394.         signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
    395.     }
    396. #endif
    397.  
    398.     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
    399.     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
    400. #ifdef SIGXCPU
    401.     signal(SIGXCPU, sigterm_handler);
    402. #endif
    403. #if HAVE_SETCONSOLECTRLHANDLER
    404.     SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
    405. #endif
    406. }
    407.  
    408. /* read a key without blocking */
    409. static int read_key(void)
    410. {
    411.     unsigned char ch;
    412. #if HAVE_TERMIOS_H
    413.     int n = 1;
    414.     struct timeval tv;
    415.     fd_set rfds;
    416.  
    417.     FD_ZERO(&rfds);
    418.     FD_SET(0, &rfds);
    419.     tv.tv_sec = 0;
    420.     tv.tv_usec = 0;
    421.     n = select(1, &rfds, NULL, NULL, &tv);
    422.     if (n > 0) {
    423.         n = read(0, &ch, 1);
    424.         if (n == 1)
    425.             return ch;
    426.  
    427.         return n;
    428.     }
    429. #elif HAVE_KBHIT
    430. #    if HAVE_PEEKNAMEDPIPE
    431.     static int is_pipe;
    432.     static HANDLE input_handle;
    433.     DWORD dw, nchars;
    434.     if(!input_handle){
    435.         input_handle = GetStdHandle(STD_INPUT_HANDLE);
    436.         is_pipe = !GetConsoleMode(input_handle, &dw);
    437.     }
    438.  
    439.     if (is_pipe) {
    440.         /* When running under a GUI, you will end here. */
    441.         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
    442.             // input pipe may have been closed by the program that ran ffmpeg
    443.             return -1;
    444.         }
    445.         //Read it
    446.         if(nchars != 0) {
    447.             read(0, &ch, 1);
    448.             return ch;
    449.         }else{
    450.             return -1;
    451.         }
    452.     }
    453. #    endif
    454.     if(kbhit())
    455.         return(getch());
    456. #endif
    457.     return -1;
    458. }
    459.  
    460. static int decode_interrupt_cb(void *ctx)
    461. {
    462.     return received_nb_signals > atomic_load(&transcode_init_done);
    463. }
    464.  
    465. const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
    466.  
    467. static void ffmpeg_cleanup(int ret)
    468. {
    469.     int i, j;
    470.  
    471.     if (do_benchmark) {
    472.         int maxrss = getmaxrss() / 1024;
    473.         av_log(NULL, AV_LOG_INFO, "bench: maxrss=%ikB\n", maxrss);
    474.     }
    475.  
    476.     for (i = 0; i < nb_filtergraphs; i++) {
    477.         FilterGraph *fg = filtergraphs[i];
    478.         avfilter_graph_free(&fg->graph);
    479.         for (j = 0; j < fg->nb_inputs; j++) {
    480.             while (av_fifo_size(fg->inputs[j]->frame_queue)) {
    481.                 AVFrame *frame;
    482.                 av_fifo_generic_read(fg->inputs[j]->frame_queue, &frame,
    483.                                      sizeof(frame), NULL);
    484.                 av_frame_free(&frame);
    485.             }
    486.             av_fifo_free(fg->inputs[j]->frame_queue);
    487.             if (fg->inputs[j]->ist->sub2video.sub_queue) {
    488.                 while (av_fifo_size(fg->inputs[j]->ist->sub2video.sub_queue)) {
    489.                     AVSubtitle sub;
    490.                     av_fifo_generic_read(fg->inputs[j]->ist->sub2video.sub_queue,
    491.                                          &sub, sizeof(sub), NULL);
    492.                     avsubtitle_free(&sub);
    493.                 }
    494.                 av_fifo_free(fg->inputs[j]->ist->sub2video.sub_queue);
    495.             }
    496.             av_buffer_unref(&fg->inputs[j]->hw_frames_ctx);
    497.             av_freep(&fg->inputs[j]->name);
    498.             av_freep(&fg->inputs[j]);
    499.         }
    500.         av_freep(&fg->inputs);
    501.         for (j = 0; j < fg->nb_outputs; j++) {
    502.             av_freep(&fg->outputs[j]->name);
    503.             av_freep(&fg->outputs[j]->formats);
    504.             av_freep(&fg->outputs[j]->channel_layouts);
    505.             av_freep(&fg->outputs[j]->sample_rates);
    506.             av_freep(&fg->outputs[j]);
    507.         }
    508.         av_freep(&fg->outputs);
    509.         av_freep(&fg->graph_desc);
    510.  
    511.         av_freep(&filtergraphs[i]);
    512.     }
    513.     av_freep(&filtergraphs);
    514.  
    515.     av_freep(&subtitle_out);
    516.  
    517.     /* close files */
    518.     for (i = 0; i < nb_output_files; i++) {
    519.         OutputFile *of = output_files[i];
    520.         AVFormatContext *s;
    521.         if (!of)
    522.             continue;
    523.         s = of->ctx;
    524.         if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))
    525.             avio_closep(&s->pb);
    526.         avformat_free_context(s);
    527.         av_dict_free(&of->opts);
    528.  
    529.         av_freep(&output_files[i]);
    530.     }
    531.     for (i = 0; i < nb_output_streams; i++) {
    532.         OutputStream *ost = output_streams[i];
    533.  
    534.         if (!ost)
    535.             continue;
    536.  
    537.         for (j = 0; j < ost->nb_bitstream_filters; j++)
    538.             av_bsf_free(&ost->bsf_ctx[j]);
    539.         av_freep(&ost->bsf_ctx);
    540.         av_freep(&ost->bsf_extradata_updated);
    541.  
    542.         av_frame_free(&ost->filtered_frame);
    543.         av_frame_free(&ost->last_frame);
    544.         av_dict_free(&ost->encoder_opts);
    545.  
    546.         av_parser_close(ost->parser);
    547.         avcodec_free_context(&ost->parser_avctx);
    548.  
    549.         av_freep(&ost->forced_keyframes);
    550.         av_expr_free(ost->forced_keyframes_pexpr);
    551.         av_freep(&ost->avfilter);
    552.         av_freep(&ost->logfile_prefix);
    553.  
    554.         av_freep(&ost->audio_channels_map);
    555.         ost->audio_channels_mapped = 0;
    556.  
    557.         av_dict_free(&ost->sws_dict);
    558.  
    559.         avcodec_free_context(&ost->enc_ctx);
    560.         avcodec_parameters_free(&ost->ref_par);
    561.  
    562.         if (ost->muxing_queue) {
    563.             while (av_fifo_size(ost->muxing_queue)) {
    564.                 AVPacket pkt;
    565.                 av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
    566.                 av_packet_unref(&pkt);
    567.             }
    568.             av_fifo_freep(&ost->muxing_queue);
    569.         }
    570.  
    571.         av_freep(&output_streams[i]);
    572.     }
    573. #if HAVE_PTHREADS
    574.     free_input_threads();
    575. #endif
    576.     for (i = 0; i < nb_input_files; i++) {
    577.         avformat_close_input(&input_files[i]->ctx);
    578.         av_freep(&input_files[i]);
    579.     }
    580.     for (i = 0; i < nb_input_streams; i++) {
    581.         InputStream *ist = input_streams[i];
    582.  
    583.         av_frame_free(&ist->decoded_frame);
    584.         av_frame_free(&ist->filter_frame);
    585.         av_dict_free(&ist->decoder_opts);
    586.         avsubtitle_free(&ist->prev_sub.subtitle);
    587.         av_frame_free(&ist->sub2video.frame);
    588.         av_freep(&ist->filters);
    589.         av_freep(&ist->hwaccel_device);
    590.         av_freep(&ist->dts_buffer);
    591.  
    592.         avcodec_free_context(&ist->dec_ctx);
    593.  
    594.         av_freep(&input_streams[i]);
    595.     }
    596.  
    597.     if (vstats_file) {
    598.         if (fclose(vstats_file))
    599.             av_log(NULL, AV_LOG_ERROR,
    600.                    "Error closing vstats file, loss of information possible: %s\n",
    601.                    av_err2str(AVERROR(errno)));
    602.     }
    603.     av_freep(&vstats_filename);
    604.  
    605.     av_freep(&input_streams);
    606.     av_freep(&input_files);
    607.     av_freep(&output_streams);
    608.     av_freep(&output_files);
    609.  
    610.     uninit_opts();
    611.  
    612.     avformat_network_deinit();
    613.  
    614.     if (received_sigterm) {
    615.         av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
    616.                (int) received_sigterm);
    617.     } else if (ret && atomic_load(&transcode_init_done)) {
    618.         av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
    619.     }
    620.     term_exit();
    621.     ffmpeg_exited = 1;
    622. }
    623.  
    624. void remove_avoptions(AVDictionary **a, AVDictionary *b)
    625. {
    626.     AVDictionaryEntry *t = NULL;
    627.  
    628.     while ((t = av_dict_get(b, "", t, AV_DICT_IGNORE_SUFFIX))) {
    629.         av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
    630.     }
    631. }
    632.  
    633. void assert_avoptions(AVDictionary *m)
    634. {
    635.     AVDictionaryEntry *t;
    636.     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
    637.         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
    638.         exit_program(1);
    639.     }
    640. }
    641.  
    642. static void abort_codec_experimental(AVCodec *c, int encoder)
    643. {
    644.     exit_program(1);
    645. }
    646.  
    647. static void update_benchmark(const char *fmt, ...)
    648. {
    649.     if (do_benchmark_all) {
    650.         int64_t t = getutime();
    651.         va_list va;
    652.         char buf[1024];
    653.  
    654.         if (fmt) {
    655.             va_start(va, fmt);
    656.             vsnprintf(buf, sizeof(buf), fmt, va);
    657.             va_end(va);
    658.             av_log(NULL, AV_LOG_INFO, "bench: %8"PRIu64" %s \n", t - current_time, buf);
    659.         }
    660.         current_time = t;
    661.     }
    662. }
    663.  
    664. static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream, OSTFinished others)
    665. {
    666.     int i;
    667.     for (i = 0; i < nb_output_streams; i++) {
    668.         OutputStream *ost2 = output_streams[i];
    669.         ost2->finished |= ost == ost2 ? this_stream : others;
    670.     }
    671. }
    672.  
    673. static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
    674. {
    675.     AVFormatContext *s = of->ctx;
    676.     AVStream *st = ost->st;
    677.     int ret;
    678.  
    679.     /*
    680.      * Audio encoders may split the packets --  #frames in != #packets out.
    681.      * But there is no reordering, so we can limit the number of output packets
    682.      * by simply dropping them here.
    683.      * Counting encoded video frames needs to be done separately because of
    684.      * reordering, see do_video_out().
    685.      * Do not count the packet when unqueued because it has been counted when queued.
    686.      */
    687.     if (!(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && ost->encoding_needed) && !unqueue) {
    688.         if (ost->frame_number >= ost->max_frames) {
    689.             av_packet_unref(pkt);
    690.             return;
    691.         }
    692.         ost->frame_number++;
    693.     }
    694.  
    695.     if (!of->header_written) {
    696.         AVPacket tmp_pkt = {0};
    697.         /* the muxer is not initialized yet, buffer the packet */
    698.         if (!av_fifo_space(ost->muxing_queue)) {
    699.             int new_size = FFMIN(2 * av_fifo_size(ost->muxing_queue),
    700.                                  ost->max_muxing_queue_size);
    701.             if (new_size <= av_fifo_size(ost->muxing_queue)) {
    702.                 av_log(NULL, AV_LOG_ERROR,
    703.                        "Too many packets buffered for output stream %d:%d.\n",
    704.                        ost->file_index, ost->st->index);
    705.                 exit_program(1);
    706.             }
    707.             ret = av_fifo_realloc2(ost->muxing_queue, new_size);
    708.             if (ret < 0)
    709.                 exit_program(1);
    710.         }
    711.         ret = av_packet_ref(&tmp_pkt, pkt);
    712.         if (ret < 0)
    713.             exit_program(1);
    714.         av_fifo_generic_write(ost->muxing_queue, &tmp_pkt, sizeof(tmp_pkt), NULL);
    715.         av_packet_unref(pkt);
    716.         return;
    717.     }
    718.  
    719.     if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
    720.         (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
    721.         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
    722.  
    723.     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
    724.         int i;
    725.         uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
    726.                                               NULL);
    727.         ost->quality = sd ? AV_RL32(sd) : -1;
    728.         ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
    729.  
    730.         for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
    731.             if (sd && i < sd[5])
    732.                 ost->error[i] = AV_RL64(sd + 8 + 8*i);
    733.             else
    734.                 ost->error[i] = -1;
    735.         }
    736.  
    737.         if (ost->frame_rate.num && ost->is_cfr) {
    738.             if (pkt->duration > 0)
    739.                 av_log(NULL, AV_LOG_WARNING, "Overriding packet duration by frame rate, this should not happen\n");
    740.             pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
    741.                                          ost->mux_timebase);
    742.         }
    743.     }
    744.  
    745.     av_packet_rescale_ts(pkt, ost->mux_timebase, ost->st->time_base);
    746.  
    747.     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
    748.         if (pkt->dts != AV_NOPTS_VALUE &&
    749.             pkt->pts != AV_NOPTS_VALUE &&
    750.             pkt->dts > pkt->pts) {
    751.             av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
    752.                    pkt->dts, pkt->pts,
    753.                    ost->file_index, ost->st->index);
    754.             pkt->pts =
    755.             pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1
    756.                      - FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)
    757.                      - FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);
    758.         }
    759.         if ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
    760.             pkt->dts != AV_NOPTS_VALUE &&
    761.             !(st->codecpar->codec_id == AV_CODEC_ID_VP9 && ost->stream_copy) &&
    762.             ost->last_mux_dts != AV_NOPTS_VALUE) {
    763.             int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
    764.             if (pkt->dts < max) {
    765.                 int loglevel = max - pkt->dts > 2 || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
    766.                 av_log(s, loglevel, "Non-monotonous DTS in output stream "
    767.                        "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
    768.                        ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
    769.                 if (exit_on_error) {
    770.                     av_log(NULL, AV_LOG_FATAL, "aborting.\n");
    771.                     exit_program(1);
    772.                 }
    773.                 av_log(s, loglevel, "changing to %"PRId64". This may result "
    774.                        "in incorrect timestamps in the output file.\n",
    775.                        max);
    776.                 if (pkt->pts >= pkt->dts)
    777.                     pkt->pts = FFMAX(pkt->pts, max);
    778.                 pkt->dts = max;
    779.             }
    780.         }
    781.     }
    782.     ost->last_mux_dts = pkt->dts;
    783.  
    784.     ost->data_size += pkt->size;
    785.     ost->packets_written++;
    786.  
    787.     pkt->stream_index = ost->index;
    788.  
    789.     if (debug_ts) {
    790.         av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
    791.                 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
    792.                 av_get_media_type_string(ost->enc_ctx->codec_type),
    793.                 av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
    794.                 av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
    795.                 pkt->size
    796.               );
    797.     }
    798.  
    799.     ret = av_interleaved_write_frame(s, pkt);
    800.     if (ret < 0) {
    801.         print_error("av_interleaved_write_frame()", ret);
    802.         main_return_code = 1;
    803.         close_all_output_streams(ost, MUXER_FINISHED | ENCODER_FINISHED, ENCODER_FINISHED);
    804.     }
    805.     av_packet_unref(pkt);
    806. }
    807.  
    808. static void close_output_stream(OutputStream *ost)
    809. {
    810.     OutputFile *of = output_files[ost->file_index];
    811.  
    812.     ost->finished |= ENCODER_FINISHED;
    813.     if (of->shortest) {
    814.         int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);
    815.         of->recording_time = FFMIN(of->recording_time, end);
    816.     }
    817. }
    818.  
    819. static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
    820. {
    821.     int ret = 0;
    822.  
    823.     /* apply the output bitstream filters, if any */
    824.     if (ost->nb_bitstream_filters) {
    825.         int idx;
    826.  
    827.         ret = av_bsf_send_packet(ost->bsf_ctx[0], pkt);
    828.         if (ret < 0)
    829.             goto finish;
    830.  
    831.         idx = 1;
    832.         while (idx) {
    833.             /* get a packet from the previous filter up the chain */
    834.             ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
    835.             if (ret == AVERROR(EAGAIN)) {
    836.                 ret = 0;
    837.                 idx--;
    838.                 continue;
    839.             } else if (ret < 0)
    840.                 goto finish;
    841.             /* HACK! - aac_adtstoasc updates extradata after filtering the first frame when
    842.              * the api states this shouldn't happen after init(). Propagate it here to the
    843.              * muxer and to the next filters in the chain to workaround this.
    844.              * TODO/FIXME - Make aac_adtstoasc use new packet side data instead of changing
    845.              * par_out->extradata and adapt muxers accordingly to get rid of this. */
    846.             if (!(ost->bsf_extradata_updated[idx - 1] & 1)) {
    847.                 ret = avcodec_parameters_copy(ost->st->codecpar, ost->bsf_ctx[idx - 1]->par_out);
    848.                 if (ret < 0)
    849.                     goto finish;
    850.                 ost->bsf_extradata_updated[idx - 1] |= 1;
    851.             }
    852.  
    853.             /* send it to the next filter down the chain or to the muxer */
    854.             if (idx < ost->nb_bitstream_filters) {
    855.                 /* HACK/FIXME! - See above */
    856.                 if (!(ost->bsf_extradata_updated[idx] & 2)) {
    857.                     ret = avcodec_parameters_copy(ost->bsf_ctx[idx]->par_out, ost->bsf_ctx[idx - 1]->par_out);
    858.                     if (ret < 0)
    859.                         goto finish;
    860.                     ost->bsf_extradata_updated[idx] |= 2;
    861.                 }
    862.                 ret = av_bsf_send_packet(ost->bsf_ctx[idx], pkt);
    863.                 if (ret < 0)
    864.                     goto finish;
    865.                 idx++;
    866.             } else
    867.                 write_packet(of, pkt, ost, 0);
    868.         }
    869.     } else
    870.         write_packet(of, pkt, ost, 0);
    871.  
    872. finish:
    873.     if (ret < 0 && ret != AVERROR_EOF) {
    874.         av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
    875.                "packet for stream #%d:%d.\n", ost->file_index, ost->index);
    876.         if(exit_on_error)
    877.             exit_program(1);
    878.     }
    879. }
    880.  
    881. static int check_recording_time(OutputStream *ost)
    882. {
    883.     OutputFile *of = output_files[ost->file_index];
    884.  
    885.     if (of->recording_time != INT64_MAX &&
    886.         av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
    887.                       AV_TIME_BASE_Q) >= 0) {
    888.         close_output_stream(ost);
    889.         return 0;
    890.     }
    891.     return 1;
    892. }
    893.  
    894. static void do_audio_out(OutputFile *of, OutputStream *ost,
    895.                          AVFrame *frame)
    896. {
    897.     AVCodecContext *enc = ost->enc_ctx;
    898.     AVPacket pkt;
    899.     int ret;
    900.  
    901.     av_init_packet(&pkt);
    902.     pkt.data = NULL;
    903.     pkt.size = 0;
    904.  
    905.     if (!check_recording_time(ost))
    906.         return;
    907.  
    908.     if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
    909.         frame->pts = ost->sync_opts;
    910.     ost->sync_opts = frame->pts + frame->nb_samples;
    911.     ost->samples_encoded += frame->nb_samples;
    912.     ost->frames_encoded++;
    913.  
    914.     av_assert0(pkt.size || !pkt.data);
    915.     update_benchmark(NULL);
    916.     if (debug_ts) {
    917.         av_log(NULL, AV_LOG_INFO, "encoder <- type:audio "
    918.                "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
    919.                av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
    920.                enc->time_base.num, enc->time_base.den);
    921.     }
    922.  
    923.     ret = avcodec_send_frame(enc, frame);
    924.     if (ret < 0)
    925.         goto error;
    926.  
    927.     while (1) {
    928.         ret = avcodec_receive_packet(enc, &pkt);
    929.         if (ret == AVERROR(EAGAIN))
    930.             break;
    931.         if (ret < 0)
    932.             goto error;
    933.  
    934.         update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
    935.  
    936.         av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
    937.  
    938.         if (debug_ts) {
    939.             av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
    940.                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
    941.                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
    942.                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
    943.         }
    944.  
    945.         output_packet(of, &pkt, ost);
    946.     }
    947.  
    948.     return;
    949. error:
    950.     av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
    951.     exit_program(1);
    952. }
    953.  
    954. static void do_subtitle_out(OutputFile *of,
    955.                             OutputStream *ost,
    956.                             AVSubtitle *sub)
    957. {
    958.     int subtitle_out_max_size = 1024 * 1024;
    959.     int subtitle_out_size, nb, i;
    960.     AVCodecContext *enc;
    961.     AVPacket pkt;
    962.     int64_t pts;
    963.  
    964.     if (sub->pts == AV_NOPTS_VALUE) {
    965.         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
    966.         if (exit_on_error)
    967.             exit_program(1);
    968.         return;
    969.     }
    970.  
    971.     enc = ost->enc_ctx;
    972.  
    973.     if (!subtitle_out) {
    974.         subtitle_out = av_malloc(subtitle_out_max_size);
    975.         if (!subtitle_out) {
    976.             av_log(NULL, AV_LOG_FATAL, "Failed to allocate subtitle_out\n");
    977.             exit_program(1);
    978.         }
    979.     }
    980.  
    981.     /* Note: DVB subtitle need one packet to draw them and one other
    982.        packet to clear them */
    983.     /* XXX: signal it in the codec context ? */
    984.     if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
    985.         nb = 2;
    986.     else
    987.         nb = 1;
    988.  
    989.     /* shift timestamp to honor -ss and make check_recording_time() work with -t */
    990.     pts = sub->pts;
    991.     if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
    992.         pts -= output_files[ost->file_index]->start_time;
    993.     for (i = 0; i < nb; i++) {
    994.         unsigned save_num_rects = sub->num_rects;
    995.  
    996.         ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
    997.         if (!check_recording_time(ost))
    998.             return;
    999.  
    1000.         sub->pts = pts;
    1001.         // start_display_time is required to be 0
    1002.         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
    1003.         sub->end_display_time  -= sub->start_display_time;
    1004.         sub->start_display_time = 0;
    1005.         if (i == 1)
    1006.             sub->num_rects = 0;
    1007.  
    1008.         ost->frames_encoded++;
    1009.  
    1010.         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
    1011.                                                     subtitle_out_max_size, sub);
    1012.         if (i == 1)
    1013.             sub->num_rects = save_num_rects;
    1014.         if (subtitle_out_size < 0) {
    1015.             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
    1016.             exit_program(1);
    1017.         }
    1018.  
    1019.         av_init_packet(&pkt);
    1020.         pkt.data = subtitle_out;
    1021.         pkt.size = subtitle_out_size;
    1022.         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->mux_timebase);
    1023.         pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
    1024.         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
    1025.             /* XXX: the pts correction is handled here. Maybe handling
    1026.                it in the codec would be better */
    1027.             if (i == 0)
    1028.                 pkt.pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
    1029.             else
    1030.                 pkt.pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
    1031.         }
    1032.         pkt.dts = pkt.pts;
    1033.         output_packet(of, &pkt, ost);
    1034.     }
    1035. }
    1036.  
    1037. static void do_video_out(OutputFile *of,
    1038.                          OutputStream *ost,
    1039.                          AVFrame *next_picture,
    1040.                          double sync_ipts)
    1041. {
    1042.     int ret, format_video_sync;
    1043.     AVPacket pkt;
    1044.     AVCodecContext *enc = ost->enc_ctx;
    1045.     AVCodecParameters *mux_par = ost->st->codecpar;
    1046.     AVRational frame_rate;
    1047.     int nb_frames, nb0_frames, i;
    1048.     double delta, delta0;
    1049.     double duration = 0;
    1050.     int frame_size = 0;
    1051.     InputStream *ist = NULL;
    1052.     AVFilterContext *filter = ost->filter->filter;
    1053.  
    1054.     if (ost->source_index >= 0)
    1055.         ist = input_streams[ost->source_index];
    1056.  
    1057.     frame_rate = av_buffersink_get_frame_rate(filter);
    1058.     if (frame_rate.num > 0 && frame_rate.den > 0)
    1059.         duration = 1/(av_q2d(frame_rate) * av_q2d(enc->time_base));
    1060.  
    1061.     if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
    1062.         duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
    1063.  
    1064.     if (!ost->filters_script &&
    1065.         !ost->filters &&
    1066.         next_picture &&
    1067.         ist &&
    1068.         lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
    1069.         duration = lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
    1070.     }
    1071.  
    1072.     if (!next_picture) {
    1073.         //end, flushing
    1074.         nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
    1075.                                           ost->last_nb0_frames[1],
    1076.                                           ost->last_nb0_frames[2]);
    1077.     } else {
    1078.         delta0 = sync_ipts - ost->sync_opts; // delta0 is the "drift" between the input frame (next_picture) and where it would fall in the output.
    1079.         delta  = delta0 + duration;
    1080.  
    1081.         /* by default, we output a single frame */
    1082.         nb0_frames = 0; // tracks the number of times the PREVIOUS frame should be duplicated, mostly for variable framerate (VFR)
    1083.         nb_frames = 1;
    1084.  
    1085.         format_video_sync = video_sync_method;
    1086.         if (format_video_sync == VSYNC_AUTO) {
    1087.             if(!strcmp(of->ctx->oformat->name, "avi")) {
    1088.                 format_video_sync = VSYNC_VFR;
    1089.             } else
    1090.                 format_video_sync = (of->ctx->oformat->flags & AVFMT_VARIABLE_FPS) ? ((of->ctx->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
    1091.             if (   ist
    1092.                 && format_video_sync == VSYNC_CFR
    1093.                 && input_files[ist->file_index]->ctx->nb_streams == 1
    1094.                 && input_files[ist->file_index]->input_ts_offset == 0) {
    1095.                 format_video_sync = VSYNC_VSCFR;
    1096.             }
    1097.             if (format_video_sync == VSYNC_CFR && copy_ts) {
    1098.                 format_video_sync = VSYNC_VSCFR;
    1099.             }
    1100.         }
    1101.         ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
    1102.  
    1103.         if (delta0 < 0 &&
    1104.             delta > 0 &&
    1105.             format_video_sync != VSYNC_PASSTHROUGH &&
    1106.             format_video_sync != VSYNC_DROP) {
    1107.             if (delta0 < -0.6) {
    1108.                 av_log(NULL, AV_LOG_WARNING, "Past duration %f too large\n", -delta0);
    1109.             } else
    1110.                 av_log(NULL, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
    1111.             sync_ipts = ost->sync_opts;
    1112.             duration += delta0;
    1113.             delta0 = 0;
    1114.         }
    1115.  
    1116.         switch (format_video_sync) {
    1117.         case VSYNC_VSCFR:
    1118.             if (ost->frame_number == 0 && delta0 >= 0.5) {
    1119.                 av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
    1120.                 delta = duration;
    1121.                 delta0 = 0;
    1122.                 ost->sync_opts = lrint(sync_ipts);
    1123.             }
    1124.         case VSYNC_CFR:
    1125.             // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
    1126.             if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
    1127.                 nb_frames = 0;
    1128.             } else if (delta < -1.1)
    1129.                 nb_frames = 0;
    1130.             else if (delta > 1.1) {
    1131.                 nb_frames = lrintf(delta);
    1132.                 if (delta0 > 1.1)
    1133.                     nb0_frames = lrintf(delta0 - 0.6);
    1134.             }
    1135.             break;
    1136.         case VSYNC_VFR:
    1137.             if (delta <= -0.6)
    1138.                 nb_frames = 0;
    1139.             else if (delta > 0.6)
    1140.                 ost->sync_opts = lrint(sync_ipts);
    1141.             break;
    1142.         case VSYNC_DROP:
    1143.         case VSYNC_PASSTHROUGH:
    1144.             ost->sync_opts = lrint(sync_ipts);
    1145.             break;
    1146.         default:
    1147.             av_assert0(0);
    1148.         }
    1149.     }
    1150.  
    1151.     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
    1152.     nb0_frames = FFMIN(nb0_frames, nb_frames);
    1153.  
    1154.     memmove(ost->last_nb0_frames + 1,
    1155.             ost->last_nb0_frames,
    1156.             sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
    1157.     ost->last_nb0_frames[0] = nb0_frames;
    1158.  
    1159.     if (nb0_frames == 0 && ost->last_dropped) {
    1160.         nb_frames_drop++;
    1161.         av_log(NULL, AV_LOG_VERBOSE,
    1162.                "*** dropping frame %d from stream %d at ts %"PRId64"\n",
    1163.                ost->frame_number, ost->st->index, ost->last_frame->pts);
    1164.     }
    1165.     if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) {
    1166.         if (nb_frames > dts_error_threshold * 30) {
    1167.             av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
    1168.             nb_frames_drop++;
    1169.             return;
    1170.         }
    1171.         nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
    1172.         av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
    1173.         if (nb_frames_dup > dup_warning) {
    1174.             av_log(NULL, AV_LOG_WARNING, "More than %d frames duplicated\n", dup_warning);
    1175.             dup_warning *= 10;
    1176.         }
    1177.     }
    1178.     ost->last_dropped = nb_frames == nb0_frames && next_picture;
    1179.  
    1180.   /* duplicates frame if needed */
    1181.   for (i = 0; i < nb_frames; i++) {
    1182.     AVFrame *in_picture;
    1183.     av_init_packet(&pkt);
    1184.     pkt.data = NULL;
    1185.     pkt.size = 0;
    1186.  
    1187.     if (i < nb0_frames && ost->last_frame) {
    1188.         in_picture = ost->last_frame;
    1189.     } else
    1190.         in_picture = next_picture;
    1191.  
    1192.     if (!in_picture)
    1193.         return;
    1194.  
    1195.     in_picture->pts = ost->sync_opts;
    1196.  
    1197. #if 1
    1198.     if (!check_recording_time(ost))
    1199. #else
    1200.     if (ost->frame_number >= ost->max_frames)
    1201. #endif
    1202.         return;
    1203.  
    1204. #if FF_API_LAVF_FMT_RAWPICTURE
    1205.     if (of->ctx->oformat->flags & AVFMT_RAWPICTURE &&
    1206.         enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
    1207.         /* raw pictures are written as AVPicture structure to
    1208.            avoid any copies. We support temporarily the older
    1209.            method. */
    1210.         if (in_picture->interlaced_frame)
    1211.             mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
    1212.         else
    1213.             mux_par->field_order = AV_FIELD_PROGRESSIVE;
    1214.         pkt.data   = (uint8_t *)in_picture;
    1215.         pkt.size   =  sizeof(AVPicture);
    1216.         pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->mux_timebase);
    1217.         pkt.flags |= AV_PKT_FLAG_KEY;
    1218.  
    1219.         output_packet(of, &pkt, ost);
    1220.     } else
    1221. #endif
    1222.     {
    1223.         int forced_keyframe = 0;
    1224.         double pts_time;
    1225.  
    1226.         if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
    1227.             ost->top_field_first >= 0)
    1228.             in_picture->top_field_first = !!ost->top_field_first;
    1229.  
    1230.         if (in_picture->interlaced_frame) {
    1231.             if (enc->codec->id == AV_CODEC_ID_MJPEG)
    1232.                 mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
    1233.             else
    1234.                 mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
    1235.         } else
    1236.             mux_par->field_order = AV_FIELD_PROGRESSIVE;
    1237.  
    1238.         in_picture->quality = enc->global_quality;
    1239.         in_picture->pict_type = 0;
    1240.  
    1241.         pts_time = in_picture->pts != AV_NOPTS_VALUE ?
    1242.             in_picture->pts * av_q2d(enc->time_base) : NAN;
    1243.         if (ost->forced_kf_index < ost->forced_kf_count &&
    1244.             in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
    1245.             ost->forced_kf_index++;
    1246.             forced_keyframe = 1;
    1247.         } else if (ost->forced_keyframes_pexpr) {
    1248.             double res;
    1249.             ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
    1250.             res = av_expr_eval(ost->forced_keyframes_pexpr,
    1251.                                ost->forced_keyframes_expr_const_values, NULL);
    1252.             ff_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
    1253.                     ost->forced_keyframes_expr_const_values[FKF_N],
    1254.                     ost->forced_keyframes_expr_const_values[FKF_N_FORCED],
    1255.                     ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],
    1256.                     ost->forced_keyframes_expr_const_values[FKF_T],
    1257.                     ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],
    1258.                     res);
    1259.             if (res) {
    1260.                 forced_keyframe = 1;
    1261.                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =
    1262.                     ost->forced_keyframes_expr_const_values[FKF_N];
    1263.                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =
    1264.                     ost->forced_keyframes_expr_const_values[FKF_T];
    1265.                 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;
    1266.             }
    1267.  
    1268.             ost->forced_keyframes_expr_const_values[FKF_N] += 1;
    1269.         } else if (   ost->forced_keyframes
    1270.                    && !strncmp(ost->forced_keyframes, "source", 6)
    1271.                    && in_picture->key_frame==1) {
    1272.             forced_keyframe = 1;
    1273.         }
    1274.  
    1275.         if (forced_keyframe) {
    1276.             in_picture->pict_type = AV_PICTURE_TYPE_I;
    1277.             av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
    1278.         }
    1279.  
    1280.         update_benchmark(NULL);
    1281.         if (debug_ts) {
    1282.             av_log(NULL, AV_LOG_INFO, "encoder <- type:video "
    1283.                    "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
    1284.                    av_ts2str(in_picture->pts), av_ts2timestr(in_picture->pts, &enc->time_base),
    1285.                    enc->time_base.num, enc->time_base.den);
    1286.         }
    1287.  
    1288.         ost->frames_encoded++;
    1289.  
    1290.         ret = avcodec_send_frame(enc, in_picture);
    1291.         if (ret < 0)
    1292.             goto error;
    1293.  
    1294.         while (1) {
    1295.             ret = avcodec_receive_packet(enc, &pkt);
    1296.             update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
    1297.             if (ret == AVERROR(EAGAIN))
    1298.                 break;
    1299.             if (ret < 0)
    1300.                 goto error;
    1301.  
    1302.             if (debug_ts) {
    1303.                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
    1304.                        "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
    1305.                        av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
    1306.                        av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
    1307.             }
    1308.  
    1309.             if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
    1310.                 pkt.pts = ost->sync_opts;
    1311.  
    1312.             av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
    1313.  
    1314.             if (debug_ts) {
    1315.                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
    1316.                     "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
    1317.                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->mux_timebase),
    1318.                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->mux_timebase));
    1319.             }
    1320.  
    1321.             frame_size = pkt.size;
    1322.             output_packet(of, &pkt, ost);
    1323.  
    1324.             /* if two pass, output log */
    1325.             if (ost->logfile && enc->stats_out) {
    1326.                 fprintf(ost->logfile, "%s", enc->stats_out);
    1327.             }
    1328.         }
    1329.     }
    1330.     ost->sync_opts++;
    1331.     /*
    1332.      * For video, number of frames in == number of packets out.
    1333.      * But there may be reordering, so we can't throw away frames on encoder
    1334.      * flush, we need to limit them here, before they go into encoder.
    1335.      */
    1336.     ost->frame_number++;
    1337.  
    1338.     if (vstats_filename && frame_size)
    1339.         do_video_stats(ost, frame_size);
    1340.   }
    1341.  
    1342.     if (!ost->last_frame)
    1343.         ost->last_frame = av_frame_alloc();
    1344.     av_frame_unref(ost->last_frame);
    1345.     if (next_picture && ost->last_frame)
    1346.         av_frame_ref(ost->last_frame, next_picture);
    1347.     else
    1348.         av_frame_free(&ost->last_frame);
    1349.  
    1350.     return;
    1351. error:
    1352.     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
    1353.     exit_program(1);
    1354. }
    1355.  
    1356. static double psnr(double d)
    1357. {
    1358.     return -10.0 * log10(d);
    1359. }
    1360.  
    1361. static void do_video_stats(OutputStream *ost, int frame_size)
    1362. {
    1363.     AVCodecContext *enc;
    1364.     int frame_number;
    1365.     double ti1, bitrate, avg_bitrate;
    1366.  
    1367.     /* this is executed just the first time do_video_stats is called */
    1368.     if (!vstats_file) {
    1369.         vstats_file = fopen(vstats_filename, "w");
    1370.         if (!vstats_file) {
    1371.             perror("fopen");
    1372.             exit_program(1);
    1373.         }
    1374.     }
    1375.  
    1376.     enc = ost->enc_ctx;
    1377.     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
    1378.         frame_number = ost->st->nb_frames;
    1379.         if (vstats_version <= 1) {
    1380.             fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
    1381.                     ost->quality / (float)FF_QP2LAMBDA);
    1382.         } else  {
    1383.             fprintf(vstats_file, "out= %2d st= %2d frame= %5d q= %2.1f ", ost->file_index, ost->index, frame_number,
    1384.                     ost->quality / (float)FF_QP2LAMBDA);
    1385.         }
    1386.  
    1387.         if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
    1388.             fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
    1389.  
    1390.         fprintf(vstats_file,"f_size= %6d ", frame_size);
    1391.         /* compute pts value */
    1392.         ti1 = av_stream_get_end_pts(ost->st) * av_q2d(ost->st->time_base);
    1393.         if (ti1 < 0.01)
    1394.             ti1 = 0.01;
    1395.  
    1396.         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
    1397.         avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
    1398.         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
    1399.                (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
    1400.         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(ost->pict_type));
    1401.     }
    1402. }
    1403.  
    1404. static int init_output_stream(OutputStream *ost, char *error, int error_len);
    1405.  
    1406. static void finish_output_stream(OutputStream *ost)
    1407. {
    1408.     OutputFile *of = output_files[ost->file_index];
    1409.     int i;
    1410.  
    1411.     ost->finished = ENCODER_FINISHED | MUXER_FINISHED;
    1412.  
    1413.     if (of->shortest) {
    1414.         for (i = 0; i < of->ctx->nb_streams; i++)
    1415.             output_streams[of->ost_index + i]->finished = ENCODER_FINISHED | MUXER_FINISHED;
    1416.     }
    1417. }
    1418.  
    1419. /**
    1420.  * Get and encode new output from any of the filtergraphs, without causing
    1421.  * activity.
    1422.  *
    1423.  * @return  0 for success, <0 for severe errors
    1424.  */
    1425. static int reap_filters(int flush)
    1426. {
    1427.     AVFrame *filtered_frame = NULL;
    1428.     int i;
    1429.  
    1430.     /* Reap all buffers present in the buffer sinks */
    1431.     for (i = 0; i < nb_output_streams; i++) {
    1432.         OutputStream *ost = output_streams[i];
    1433.         OutputFile    *of = output_files[ost->file_index];
    1434.         AVFilterContext *filter;
    1435.         AVCodecContext *enc = ost->enc_ctx;
    1436.         int ret = 0;
    1437.  
    1438.         if (!ost->filter || !ost->filter->graph->graph)
    1439.             continue;
    1440.         filter = ost->filter->filter;
    1441.  
    1442.         if (!ost->initialized) {
    1443.             char error[1024] = "";
    1444.             ret = init_output_stream(ost, error, sizeof(error));
    1445.             if (ret < 0) {
    1446.                 av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
    1447.                        ost->file_index, ost->index, error);
    1448.                 exit_program(1);
    1449.             }
    1450.         }
    1451.  
    1452.         if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
    1453.             return AVERROR(ENOMEM);
    1454.         }
    1455.         filtered_frame = ost->filtered_frame;
    1456.  
    1457.         while (1) {
    1458.             double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
    1459.             ret = av_buffersink_get_frame_flags(filter, filtered_frame,
    1460.                                                AV_BUFFERSINK_FLAG_NO_REQUEST);
    1461.             if (ret < 0) {
    1462.                 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
    1463.                     av_log(NULL, AV_LOG_WARNING,
    1464.                            "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
    1465.                 } else if (flush && ret == AVERROR_EOF) {
    1466.                     if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
    1467.                         do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
    1468.                 }
    1469.                 break;
    1470.             }
    1471.             if (ost->finished) {
    1472.                 av_frame_unref(filtered_frame);
    1473.                 continue;
    1474.             }
    1475.             if (filtered_frame->pts != AV_NOPTS_VALUE) {
    1476.                 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
    1477.                 AVRational filter_tb = av_buffersink_get_time_base(filter);
    1478.                 AVRational tb = enc->time_base;
    1479.                 int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
    1480.  
    1481.                 tb.den <<= extra_bits;
    1482.                 float_pts =
    1483.                     av_rescale_q(filtered_frame->pts, filter_tb, tb) -
    1484.                     av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
    1485.                 float_pts /= 1 << extra_bits;
    1486.                 // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
    1487.                 float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
    1488.  
    1489.                 filtered_frame->pts =
    1490.                     av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
    1491.                     av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
    1492.             }
    1493.             //if (ost->source_index >= 0)
    1494.             //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
    1495.  
    1496.             switch (av_buffersink_get_type(filter)) {
    1497.             case AVMEDIA_TYPE_VIDEO:
    1498.                 if (!ost->frame_aspect_ratio.num)
    1499.                     enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
    1500.  
    1501.                 if (debug_ts) {
    1502.                     av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
    1503.                             av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
    1504.                             float_pts,
    1505.                             enc->time_base.num, enc->time_base.den);
    1506.                 }
    1507.  
    1508.                 do_video_out(of, ost, filtered_frame, float_pts);
    1509.                 break;
    1510.             case AVMEDIA_TYPE_AUDIO:
    1511.                 if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
    1512.                     enc->channels != av_frame_get_channels(filtered_frame)) {
    1513.                     av_log(NULL, AV_LOG_ERROR,
    1514.                            "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
    1515.                     break;
    1516.                 }
    1517.                 do_audio_out(of, ost, filtered_frame);
    1518.                 break;
    1519.             default:
    1520.                 // TODO support subtitle filters
    1521.                 av_assert0(0);
    1522.             }
    1523.  
    1524.             av_frame_unref(filtered_frame);
    1525.         }
    1526.     }
    1527.  
    1528.     return 0;
    1529. }
    1530.  
    1531. static void print_final_stats(int64_t total_size)
    1532. {
    1533.     uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
    1534.     uint64_t subtitle_size = 0;
    1535.     uint64_t data_size = 0;
    1536.     float percent = -1.0;
    1537.     int i, j;
    1538.     int pass1_used = 1;
    1539.  
    1540.     for (i = 0; i < nb_output_streams; i++) {
    1541.         OutputStream *ost = output_streams[i];
    1542.         switch (ost->enc_ctx->codec_type) {
    1543.             case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
    1544.             case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
    1545.             case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
    1546.             default:                 other_size += ost->data_size; break;
    1547.         }
    1548.         extra_size += ost->enc_ctx->extradata_size;
    1549.         data_size  += ost->data_size;
    1550.         if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2))
    1551.             != AV_CODEC_FLAG_PASS1)
    1552.             pass1_used = 0;
    1553.     }
    1554.  
    1555.     if (data_size && total_size>0 && total_size >= data_size)
    1556.         percent = 100.0 * (total_size - data_size) / data_size;
    1557.  
    1558.     av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
    1559.            video_size / 1024.0,
    1560.            audio_size / 1024.0,
    1561.            subtitle_size / 1024.0,
    1562.            other_size / 1024.0,
    1563.            extra_size / 1024.0);
    1564.     if (percent >= 0.0)
    1565.         av_log(NULL, AV_LOG_INFO, "%f%%", percent);
    1566.     else
    1567.         av_log(NULL, AV_LOG_INFO, "unknown");
    1568.     av_log(NULL, AV_LOG_INFO, "\n");
    1569.  
    1570.     /* print verbose per-stream stats */
    1571.     for (i = 0; i < nb_input_files; i++) {
    1572.         InputFile *f = input_files[i];
    1573.         uint64_t total_packets = 0, total_size = 0;
    1574.  
    1575.         av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
    1576.                i, f->ctx->filename);
    1577.  
    1578.         for (j = 0; j < f->nb_streams; j++) {
    1579.             InputStream *ist = input_streams[f->ist_index + j];
    1580.             enum AVMediaType type = ist->dec_ctx->codec_type;
    1581.  
    1582.             total_size    += ist->data_size;
    1583.             total_packets += ist->nb_packets;
    1584.  
    1585.             av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
    1586.                    i, j, media_type_string(type));
    1587.             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
    1588.                    ist->nb_packets, ist->data_size);
    1589.  
    1590.             if (ist->decoding_needed) {
    1591.                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
    1592.                        ist->frames_decoded);
    1593.                 if (type == AVMEDIA_TYPE_AUDIO)
    1594.                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
    1595.                 av_log(NULL, AV_LOG_VERBOSE, "; ");
    1596.             }
    1597.  
    1598.             av_log(NULL, AV_LOG_VERBOSE, "\n");
    1599.         }
    1600.  
    1601.         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
    1602.                total_packets, total_size);
    1603.     }
    1604.  
    1605.     for (i = 0; i < nb_output_files; i++) {
    1606.         OutputFile *of = output_files[i];
    1607.         uint64_t total_packets = 0, total_size = 0;
    1608.  
    1609.         av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
    1610.                i, of->ctx->filename);
    1611.  
    1612.         for (j = 0; j < of->ctx->nb_streams; j++) {
    1613.             OutputStream *ost = output_streams[of->ost_index + j];
    1614.             enum AVMediaType type = ost->enc_ctx->codec_type;
    1615.  
    1616.             total_size    += ost->data_size;
    1617.             total_packets += ost->packets_written;
    1618.  
    1619.             av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
    1620.                    i, j, media_type_string(type));
    1621.             if (ost->encoding_needed) {
    1622.                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
    1623.                        ost->frames_encoded);
    1624.                 if (type == AVMEDIA_TYPE_AUDIO)
    1625.                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
    1626.                 av_log(NULL, AV_LOG_VERBOSE, "; ");
    1627.             }
    1628.  
    1629.             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
    1630.                    ost->packets_written, ost->data_size);
    1631.  
    1632.             av_log(NULL, AV_LOG_VERBOSE, "\n");
    1633.         }
    1634.  
    1635.         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
    1636.                total_packets, total_size);
    1637.     }
    1638.     if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
    1639.         av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
    1640.         if (pass1_used) {
    1641.             av_log(NULL, AV_LOG_WARNING, "\n");
    1642.         } else {
    1643.             av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
    1644.         }
    1645.     }
    1646. }
    1647. //打印输出信息的方法
    1648. static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time,void(call_back)(int current,int total))
    1649. {
    1650.     char buf[1024];
    1651.     AVBPrint buf_script;
    1652.     OutputStream *ost;
    1653.     AVFormatContext *oc;
    1654.     int64_t total_size;
    1655.     AVCodecContext *enc;
    1656.     int frame_number, vid, i;
    1657.     double bitrate;
    1658.     double speed;
    1659.     int64_t pts = INT64_MIN + 1;
    1660.     static int64_t last_time = -1;
    1661.     static int qp_histogram[52];
    1662.     int hours, mins, secs, us;
    1663.     int ret;
    1664.     float t;
    1665.  
    1666.     if (!print_stats && !is_last_report && !progress_avio)
    1667.         return;
    1668.  
    1669.     if (!is_last_report) {
    1670.         if (last_time == -1) {
    1671.             last_time = cur_time;
    1672.             return;
    1673.         }
    1674.         if ((cur_time - last_time) < 500000)
    1675.             return;
    1676.         last_time = cur_time;
    1677.     }
    1678.  
    1679.     t = (cur_time-timer_start) / 1000000.0;
    1680.  
    1681.  
    1682.     oc = output_files[0]->ctx;
    1683.  
    1684.     total_size = avio_size(oc->pb);
    1685.     if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
    1686.         total_size = avio_tell(oc->pb);
    1687.  
    1688.     buf[0] = '\0';
    1689.     vid = 0;
    1690.     av_bprint_init(&buf_script, 0, 1);
    1691.     for (i = 0; i < nb_output_streams; i++) {
    1692.         float q = -1;
    1693.         ost = output_streams[i];
    1694.         enc = ost->enc_ctx;
    1695.         if (!ost->stream_copy)
    1696.             q = ost->quality / (float) FF_QP2LAMBDA;
    1697.  
    1698.         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
    1699.             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
    1700.             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
    1701.                        ost->file_index, ost->index, q);
    1702.         }
    1703.         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
    1704.             float fps;
    1705.  
    1706.             frame_number = ost->frame_number;
    1707.             fps = t > 1 ? frame_number / t : 0;
    1708.             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
    1709.                      frame_number, fps < 9.95, fps, q);
    1710.             av_bprintf(&buf_script, "frame=%d\n", frame_number);
    1711.             av_bprintf(&buf_script, "fps=%.1f\n", fps);
    1712.             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
    1713.                        ost->file_index, ost->index, q);
    1714.             //__android_log_print(ANDROID_LOG_ERROR,"JNI_TAG","当前压缩帧：%d",frame_number);
    1715.             int total_frame_number=input_files[0]->ctx->streams[0]->nb_frames;
    1716.             call_back(frame_number,total_frame_number);
    1717.             if (is_last_report)
    1718.                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
    1719.             if (qp_hist) {
    1720.                 int j;
    1721.                 int qp = lrintf(q);
    1722.                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
    1723.                     qp_histogram[qp]++;
    1724.                 for (j = 0; j < 32; j++)
    1725.                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", av_log2(qp_histogram[j] + 1));
    1726.             }
    1727.  
    1728.             if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
    1729.                 int j;
    1730.                 double error, error_sum = 0;
    1731.                 double scale, scale_sum = 0;
    1732.                 double p;
    1733.                 char type[3] = { 'Y','U','V' };
    1734.                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
    1735.                 for (j = 0; j < 3; j++) {
    1736.                     if (is_last_report) {
    1737.                         error = enc->error[j];
    1738.                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
    1739.                     } else {
    1740.                         error = ost->error[j];
    1741.                         scale = enc->width * enc->height * 255.0 * 255.0;
    1742.                     }
    1743.                     if (j)
    1744.                         scale /= 4;
    1745.                     error_sum += error;
    1746.                     scale_sum += scale;
    1747.                     p = psnr(error / scale);
    1748.                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
    1749.                     av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
    1750.                                ost->file_index, ost->index, type[j] | 32, p);
    1751.                 }
    1752.                 p = psnr(error_sum / scale_sum);
    1753.                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
    1754.                 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
    1755.                            ost->file_index, ost->index, p);
    1756.             }
    1757.             vid = 1;
    1758.         }
    1759.         /* compute min output value */
    1760.         if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE)
    1761.             pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
    1762.                                           ost->st->time_base, AV_TIME_BASE_Q));
    1763.         if (is_last_report)
    1764.             nb_frames_drop += ost->last_dropped;
    1765.     }
    1766.  
    1767.     secs = FFABS(pts) / AV_TIME_BASE;
    1768.     us = FFABS(pts) % AV_TIME_BASE;
    1769.     mins = secs / 60;
    1770.     secs %= 60;
    1771.     hours = mins / 60;
    1772.     mins %= 60;
    1773.  
    1774.     bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
    1775.     speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
    1776.  
    1777.     if (total_size < 0) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
    1778.                                  "size=N/A time=");
    1779.     else                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
    1780.                                  "size=%8.0fkB time=", total_size / 1024.0);
    1781.     if (pts < 0)
    1782.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "-");
    1783.     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
    1784.              "%02d:%02d:%02d.%02d ", hours, mins, secs,
    1785.              (100 * us) / AV_TIME_BASE);
    1786.  
    1787.     if (bitrate < 0) {
    1788.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=N/A");
    1789.         av_bprintf(&buf_script, "bitrate=N/A\n");
    1790.     }else{
    1791.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=%6.1fkbits/s", bitrate);
    1792.         av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
    1793.     }
    1794.  
    1795.     if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
    1796.     else                av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
    1797.     av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
    1798.     av_bprintf(&buf_script, "out_time=%02d:%02d:%02d.%06d\n",
    1799.                hours, mins, secs, us);
    1800.  
    1801.     if (nb_frames_dup || nb_frames_drop)
    1802.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
    1803.                 nb_frames_dup, nb_frames_drop);
    1804.     av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
    1805.     av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
    1806.  
    1807.     if (speed < 0) {
    1808.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=N/A");
    1809.         av_bprintf(&buf_script, "speed=N/A\n");
    1810.     } else {
    1811.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=%4.3gx", speed);
    1812.         av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
    1813.     }
    1814.  
    1815.     if (print_stats || is_last_report) {
    1816.         const char end = is_last_report ? '\n' : '\r';
    1817.         if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
    1818.             fprintf(stderr, "%s    %c", buf, end);
    1819.         } else
    1820.             av_log(NULL, AV_LOG_INFO, "%s    %c", buf, end);
    1821.  
    1822.     fflush(stderr);
    1823.     }
    1824.  
    1825.     if (progress_avio) {
    1826.         av_bprintf(&buf_script, "progress=%s\n",
    1827.                    is_last_report ? "end" : "continue");
    1828.         avio_write(progress_avio, buf_script.str,
    1829.                    FFMIN(buf_script.len, buf_script.size - 1));
    1830.         avio_flush(progress_avio);
    1831.         av_bprint_finalize(&buf_script, NULL);
    1832.         if (is_last_report) {
    1833.             if ((ret = avio_closep(&progress_avio)) < 0)
    1834.                 av_log(NULL, AV_LOG_ERROR,
    1835.                        "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
    1836.         }
    1837.     }
    1838.  
    1839.     if (is_last_report)
    1840.         print_final_stats(total_size);
    1841. }
    1842.  
    1843. static void flush_encoders(void)
    1844. {
    1845.     int i, ret;
    1846.  
    1847.     for (i = 0; i < nb_output_streams; i++) {
    1848.         OutputStream   *ost = output_streams[i];
    1849.         AVCodecContext *enc = ost->enc_ctx;
    1850.         OutputFile      *of = output_files[ost->file_index];
    1851.  
    1852.         if (!ost->encoding_needed)
    1853.             continue;
    1854.  
    1855.         // Try to enable encoding with no input frames.
    1856.         // Maybe we should just let encoding fail instead.
    1857.         if (!ost->initialized) {
    1858.             FilterGraph *fg = ost->filter->graph;
    1859.             char error[1024] = "";
    1860.  
    1861.             av_log(NULL, AV_LOG_WARNING,
    1862.                    "Finishing stream %d:%d without any data written to it.\n",
    1863.                    ost->file_index, ost->st->index);
    1864.  
    1865.             if (ost->filter && !fg->graph) {
    1866.                 int x;
    1867.                 for (x = 0; x < fg->nb_inputs; x++) {
    1868.                     InputFilter *ifilter = fg->inputs[x];
    1869.                     if (ifilter->format < 0) {
    1870.                         AVCodecParameters *par = ifilter->ist->st->codecpar;
    1871.                         // We never got any input. Set a fake format, which will
    1872.                         // come from libavformat.
    1873.                         ifilter->format                 = par->format;
    1874.                         ifilter->sample_rate            = par->sample_rate;
    1875.                         ifilter->channels               = par->channels;
    1876.                         ifilter->channel_layout         = par->channel_layout;
    1877.                         ifilter->width                  = par->width;
    1878.                         ifilter->height                 = par->height;
    1879.                         ifilter->sample_aspect_ratio    = par->sample_aspect_ratio;
    1880.                     }
    1881.                 }
    1882.  
    1883.                 if (!ifilter_has_all_input_formats(fg))
    1884.                     continue;
    1885.  
    1886.                 ret = configure_filtergraph(fg);
    1887.                 if (ret < 0) {
    1888.                     av_log(NULL, AV_LOG_ERROR, "Error configuring filter graph\n");
    1889.                     exit_program(1);
    1890.                 }
    1891.  
    1892.                 finish_output_stream(ost);
    1893.             }
    1894.  
    1895.             ret = init_output_stream(ost, error, sizeof(error));
    1896.             if (ret < 0) {
    1897.                 av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
    1898.                        ost->file_index, ost->index, error);
    1899.                 exit_program(1);
    1900.             }
    1901.         }
    1902.  
    1903.         if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
    1904.             continue;
    1905. #if FF_API_LAVF_FMT_RAWPICTURE
    1906.         if (enc->codec_type == AVMEDIA_TYPE_VIDEO && (of->ctx->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
    1907.             continue;
    1908. #endif
    1909.  
    1910.         if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
    1911.             continue;
    1912.  
    1913.         for (;;) {
    1914.             const char *desc = NULL;
    1915.             AVPacket pkt;
    1916.             int pkt_size;
    1917.  
    1918.             switch (enc->codec_type) {
    1919.             case AVMEDIA_TYPE_AUDIO:
    1920.                 desc   = "audio";
    1921.                 break;
    1922.             case AVMEDIA_TYPE_VIDEO:
    1923.                 desc   = "video";
    1924.                 break;
    1925.             default:
    1926.                 av_assert0(0);
    1927.             }
    1928.  
    1929.                 av_init_packet(&pkt);
    1930.                 pkt.data = NULL;
    1931.                 pkt.size = 0;
    1932.  
    1933.                 update_benchmark(NULL);
    1934.  
    1935.                 while ((ret = avcodec_receive_packet(enc, &pkt)) == AVERROR(EAGAIN)) {
    1936.                     ret = avcodec_send_frame(enc, NULL);
    1937.                     if (ret < 0) {
    1938.                         av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
    1939.                                desc,
    1940.                                av_err2str(ret));
    1941.                         exit_program(1);
    1942.                     }
    1943.                 }
    1944.  
    1945.                 update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
    1946.                 if (ret < 0 && ret != AVERROR_EOF) {
    1947.                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
    1948.                            desc,
    1949.                            av_err2str(ret));
    1950.                     exit_program(1);
    1951.                 }
    1952.                 if (ost->logfile && enc->stats_out) {
    1953.                     fprintf(ost->logfile, "%s", enc->stats_out);
    1954.                 }
    1955.                 if (ret == AVERROR_EOF) {
    1956.                     break;
    1957.                 }
    1958.                 if (ost->finished & MUXER_FINISHED) {
    1959.                     av_packet_unref(&pkt);
    1960.                     continue;
    1961.                 }
    1962.                 av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
    1963.                 pkt_size = pkt.size;
    1964.                 output_packet(of, &pkt, ost);
    1965.                 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
    1966.                     do_video_stats(ost, pkt_size);
    1967.                 }
    1968.         }
    1969.     }
    1970. }
    1971.  
    1972. /*
    1973.  * Check whether a packet from ist should be written into ost at this time
    1974.  */
    1975. static int check_output_constraints(InputStream *ist, OutputStream *ost)
    1976. {
    1977.     OutputFile *of = output_files[ost->file_index];
    1978.     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
    1979.  
    1980.     if (ost->source_index != ist_index)
    1981.         return 0;
    1982.  
    1983.     if (ost->finished)
    1984.         return 0;
    1985.  
    1986.     if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
    1987.         return 0;
    1988.  
    1989.     return 1;
    1990. }
    1991.  
    1992. static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
    1993. {
    1994.     OutputFile *of = output_files[ost->file_index];
    1995.     InputFile   *f = input_files [ist->file_index];
    1996.     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
    1997.     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
    1998.     AVPicture pict;
    1999.     AVPacket opkt;
    2000.  
    2001.     av_init_packet(&opkt);
    2002.  
    2003.     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
    2004.         !ost->copy_initial_nonkeyframes)
    2005.         return;
    2006.  
    2007.     if (!ost->frame_number && !ost->copy_prior_start) {
    2008.         int64_t comp_start = start_time;
    2009.         if (copy_ts && f->start_time != AV_NOPTS_VALUE)
    2010.             comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
    2011.         if (pkt->pts == AV_NOPTS_VALUE ?
    2012.             ist->pts < comp_start :
    2013.             pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
    2014.             return;
    2015.     }
    2016.  
    2017.     if (of->recording_time != INT64_MAX &&
    2018.         ist->pts >= of->recording_time + start_time) {
    2019.         close_output_stream(ost);
    2020.         return;
    2021.     }
    2022.  
    2023.     if (f->recording_time != INT64_MAX) {
    2024.         start_time = f->ctx->start_time;
    2025.         if (f->start_time != AV_NOPTS_VALUE && copy_ts)
    2026.             start_time += f->start_time;
    2027.         if (ist->pts >= f->recording_time + start_time) {
    2028.             close_output_stream(ost);
    2029.             return;
    2030.         }
    2031.     }
    2032.  
    2033.     /* force the input stream PTS */
    2034.     if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
    2035.         ost->sync_opts++;
    2036.  
    2037.     if (pkt->pts != AV_NOPTS_VALUE)
    2038.         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
    2039.     else
    2040.         opkt.pts = AV_NOPTS_VALUE;
    2041.  
    2042.     if (pkt->dts == AV_NOPTS_VALUE)
    2043.         opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->mux_timebase);
    2044.     else
    2045.         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
    2046.     opkt.dts -= ost_tb_start_time;
    2047.  
    2048.     if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
    2049.         int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
    2050.         if(!duration)
    2051.             duration = ist->dec_ctx->frame_size;
    2052.         opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
    2053.                                                (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
    2054.                                                ost->mux_timebase) - ost_tb_start_time;
    2055.     }
    2056.  
    2057.     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
    2058.  
    2059.     opkt.flags    = pkt->flags;
    2060.     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
    2061.     if (  ost->st->codecpar->codec_id != AV_CODEC_ID_H264
    2062.        && ost->st->codecpar->codec_id != AV_CODEC_ID_MPEG1VIDEO
    2063.        && ost->st->codecpar->codec_id != AV_CODEC_ID_MPEG2VIDEO
    2064.        && ost->st->codecpar->codec_id != AV_CODEC_ID_VC1
    2065.        ) {
    2066.         int ret = av_parser_change(ost->parser, ost->parser_avctx,
    2067.                              &opkt.data, &opkt.size,
    2068.                              pkt->data, pkt->size,
    2069.                              pkt->flags & AV_PKT_FLAG_KEY);
    2070.         if (ret < 0) {
    2071.             av_log(NULL, AV_LOG_FATAL, "av_parser_change failed: %s\n",
    2072.                    av_err2str(ret));
    2073.             exit_program(1);
    2074.         }
    2075.         if (ret) {
    2076.             opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
    2077.             if (!opkt.buf)
    2078.                 exit_program(1);
    2079.         }
    2080.     } else {
    2081.         opkt.data = pkt->data;
    2082.         opkt.size = pkt->size;
    2083.     }
    2084.     av_copy_packet_side_data(&opkt, pkt);
    2085.  
    2086. #if FF_API_LAVF_FMT_RAWPICTURE
    2087.     if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
    2088.         ost->st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO &&
    2089.         (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
    2090.         /* store AVPicture in AVPacket, as expected by the output format */
    2091.         int ret = avpicture_fill(&pict, opkt.data, ost->st->codecpar->format, ost->st->codecpar->width, ost->st->codecpar->height);
    2092.         if (ret < 0) {
    2093.             av_log(NULL, AV_LOG_FATAL, "avpicture_fill failed: %s\n",
    2094.                    av_err2str(ret));
    2095.             exit_program(1);
    2096.         }
    2097.         opkt.data = (uint8_t *)&pict;
    2098.         opkt.size = sizeof(AVPicture);
    2099.         opkt.flags |= AV_PKT_FLAG_KEY;
    2100.     }
    2101. #endif
    2102.  
    2103.     output_packet(of, &opkt, ost);
    2104. }
    2105.  
    2106. int guess_input_channel_layout(InputStream *ist)
    2107. {
    2108.     AVCodecContext *dec = ist->dec_ctx;
    2109.  
    2110.     if (!dec->channel_layout) {
    2111.         char layout_name[256];
    2112.  
    2113.         if (dec->channels > ist->guess_layout_max)
    2114.             return 0;
    2115.         dec->channel_layout = av_get_default_channel_layout(dec->channels);
    2116.         if (!dec->channel_layout)
    2117.             return 0;
    2118.         av_get_channel_layout_string(layout_name, sizeof(layout_name),
    2119.                                      dec->channels, dec->channel_layout);
    2120.         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
    2121.                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
    2122.     }
    2123.     return 1;
    2124. }
    2125.  
    2126. static void check_decode_result(InputStream *ist, int *got_output, int ret)
    2127. {
    2128.     if (*got_output || ret<0)
    2129.         decode_error_stat[ret<0] ++;
    2130.  
    2131.     if (ret < 0 && exit_on_error)
    2132.         exit_program(1);
    2133.  
    2134.     if (exit_on_error && *got_output && ist) {
    2135.         if (av_frame_get_decode_error_flags(ist->decoded_frame) || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
    2136.             av_log(NULL, AV_LOG_FATAL, "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->filename, ist->st->index);
    2137.             exit_program(1);
    2138.         }
    2139.     }
    2140. }
    2141.  
    2142. // Filters can be configured only if the formats of all inputs are known.
    2143. static int ifilter_has_all_input_formats(FilterGraph *fg)
    2144. {
    2145.     int i;
    2146.     for (i = 0; i < fg->nb_inputs; i++) {
    2147.         if (fg->inputs[i]->format < 0 && (fg->inputs[i]->type == AVMEDIA_TYPE_AUDIO ||
    2148.                                           fg->inputs[i]->type == AVMEDIA_TYPE_VIDEO))
    2149.             return 0;
    2150.     }
    2151.     return 1;
    2152. }
    2153.  
    2154. static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
    2155. {
    2156.     FilterGraph *fg = ifilter->graph;
    2157.     int need_reinit, ret, i;
    2158.  
    2159.     /* determine if the parameters for this input changed */
    2160.     need_reinit = ifilter->format != frame->format;
    2161.  
    2162.     switch (ifilter->ist->st->codecpar->codec_type) {
    2163.     case AVMEDIA_TYPE_AUDIO:
    2164.         need_reinit |= ifilter->sample_rate    != frame->sample_rate ||
    2165.                        ifilter->channels       != frame->channels ||
    2166.                        ifilter->channel_layout != frame->channel_layout;
    2167.         break;
    2168.     case AVMEDIA_TYPE_VIDEO:
    2169.         need_reinit |= ifilter->width  != frame->width ||
    2170.                        ifilter->height != frame->height;
    2171.         break;
    2172.     }
    2173.  
    2174.     if (!ifilter->ist->reinit_filters && fg->graph)
    2175.         need_reinit = 0;
    2176.  
    2177.     if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
    2178.         (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
    2179.         need_reinit = 1;
    2180.  
    2181.     if (need_reinit) {
    2182.         ret = ifilter_parameters_from_frame(ifilter, frame);
    2183.         if (ret < 0)
    2184.             return ret;
    2185.     }
    2186.  
    2187.     /* (re)init the graph if possible, otherwise buffer the frame and return */
    2188.     if (need_reinit || !fg->graph) {
    2189.         for (i = 0; i < fg->nb_inputs; i++) {
    2190.             if (!ifilter_has_all_input_formats(fg)) {
    2191.                 AVFrame *tmp = av_frame_clone(frame);
    2192.                 if (!tmp)
    2193.                     return AVERROR(ENOMEM);
    2194.                 av_frame_unref(frame);
    2195.  
    2196.                 if (!av_fifo_space(ifilter->frame_queue)) {
    2197.                     ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
    2198.                     if (ret < 0) {
    2199.                         av_frame_free(&tmp);
    2200.                         return ret;
    2201.                     }
    2202.                 }
    2203.                 av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
    2204.                 return 0;
    2205.             }
    2206.         }
    2207.  
    2208.         ret = reap_filters(1);
    2209.         if (ret < 0 && ret != AVERROR_EOF) {
    2210.             char errbuf[128];
    2211.             av_strerror(ret, errbuf, sizeof(errbuf));
    2212.  
    2213.             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
    2214.             return ret;
    2215.         }
    2216.  
    2217.         ret = configure_filtergraph(fg);
    2218.         if (ret < 0) {
    2219.             av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
    2220.             return ret;
    2221.         }
    2222.     }
    2223.  
    2224.     ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, AV_BUFFERSRC_FLAG_PUSH);
    2225.     if (ret < 0) {
    2226.         av_log(NULL, AV_LOG_ERROR, "Error while filtering\n");
    2227.         return ret;
    2228.     }
    2229.  
    2230.     return 0;
    2231. }
    2232.  
    2233. static int ifilter_send_eof(InputFilter *ifilter)
    2234. {
    2235.     int i, j, ret;
    2236.  
    2237.     ifilter->eof = 1;
    2238.  
    2239.     if (ifilter->filter) {
    2240.         ret = av_buffersrc_add_frame_flags(ifilter->filter, NULL, AV_BUFFERSRC_FLAG_PUSH);
    2241.         if (ret < 0)
    2242.             return ret;
    2243.     } else {
    2244.         // the filtergraph was never configured
    2245.         FilterGraph *fg = ifilter->graph;
    2246.         for (i = 0; i < fg->nb_inputs; i++)
    2247.             if (!fg->inputs[i]->eof)
    2248.                 break;
    2249.         if (i == fg->nb_inputs) {
    2250.             // All the input streams have finished without the filtergraph
    2251.             // ever being configured.
    2252.             // Mark the output streams as finished.
    2253.             for (j = 0; j < fg->nb_outputs; j++)
    2254.                 finish_output_stream(fg->outputs[j]->ost);
    2255.         }
    2256.     }
    2257.  
    2258.     return 0;
    2259. }
    2260.  
    2261. // This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
    2262. // There is the following difference: if you got a frame, you must call
    2263. // it again with pkt=NULL. pkt==NULL is treated differently from pkt.size==0
    2264. // (pkt==NULL means get more output, pkt.size==0 is a flush/drain packet)
    2265. static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
    2266. {
    2267.     int ret;
    2268.  
    2269.     *got_frame = 0;
    2270.  
    2271.     if (pkt) {
    2272.         ret = avcodec_send_packet(avctx, pkt);
    2273.         // In particular, we don't expect AVERROR(EAGAIN), because we read all
    2274.         // decoded frames with avcodec_receive_frame() until done.
    2275.         if (ret < 0 && ret != AVERROR_EOF)
    2276.             return ret;
    2277.     }
    2278.  
    2279.     ret = avcodec_receive_frame(avctx, frame);
    2280.     if (ret < 0 && ret != AVERROR(EAGAIN))
    2281.         return ret;
    2282.     if (ret >= 0)
    2283.         *got_frame = 1;
    2284.  
    2285.     return 0;
    2286. }
    2287.  
    2288. static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
    2289. {
    2290.     int i, ret;
    2291.     AVFrame *f;
    2292.  
    2293.     av_assert1(ist->nb_filters > 0); /* ensure ret is initialized */
    2294.     for (i = 0; i < ist->nb_filters; i++) {
    2295.         if (i < ist->nb_filters - 1) {
    2296.             f = ist->filter_frame;
    2297.             ret = av_frame_ref(f, decoded_frame);
    2298.             if (ret < 0)
    2299.                 break;
    2300.         } else
    2301.             f = decoded_frame;
    2302.         ret = ifilter_send_frame(ist->filters[i], f);
    2303.         if (ret == AVERROR_EOF)
    2304.             ret = 0; /* ignore */
    2305.         if (ret < 0) {
    2306.             av_log(NULL, AV_LOG_ERROR,
    2307.                    "Failed to inject frame into filter network: %s\n", av_err2str(ret));
    2308.             break;
    2309.         }
    2310.     }
    2311.     return ret;
    2312. }
    2313.  
    2314. static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
    2315.                         int *decode_failed)
    2316. {
    2317.     AVFrame *decoded_frame;
    2318.     AVCodecContext *avctx = ist->dec_ctx;
    2319.     int ret, err = 0;
    2320.     AVRational decoded_frame_tb;
    2321.  
    2322.     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
    2323.         return AVERROR(ENOMEM);
    2324.     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
    2325.         return AVERROR(ENOMEM);
    2326.     decoded_frame = ist->decoded_frame;
    2327.  
    2328.     update_benchmark(NULL);
    2329.     ret = decode(avctx, decoded_frame, got_output, pkt);
    2330.     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
    2331.     if (ret < 0)
    2332.         *decode_failed = 1;
    2333.  
    2334.     if (ret >= 0 && avctx->sample_rate <= 0) {
    2335.         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
    2336.         ret = AVERROR_INVALIDDATA;
    2337.     }
    2338.  
    2339.     if (ret != AVERROR_EOF)
    2340.         check_decode_result(ist, got_output, ret);
    2341.  
    2342.     if (!*got_output || ret < 0)
    2343.         return ret;
    2344.  
    2345.     ist->samples_decoded += decoded_frame->nb_samples;
    2346.     ist->frames_decoded++;
    2347.  
    2348. #if 1
    2349.     /* increment next_dts to use for the case where the input stream does not
    2350.        have timestamps or there are multiple frames in the packet */
    2351.     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
    2352.                      avctx->sample_rate;
    2353.     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
    2354.                      avctx->sample_rate;
    2355. #endif
    2356.  
    2357.     if (decoded_frame->pts != AV_NOPTS_VALUE) {
    2358.         decoded_frame_tb   = ist->st->time_base;
    2359.     } else if (pkt && pkt->pts != AV_NOPTS_VALUE) {
    2360.         decoded_frame->pts = pkt->pts;
    2361.         decoded_frame_tb   = ist->st->time_base;
    2362.     }else {
    2363.         decoded_frame->pts = ist->dts;
    2364.         decoded_frame_tb   = AV_TIME_BASE_Q;
    2365.     }
    2366.     if (decoded_frame->pts != AV_NOPTS_VALUE)
    2367.         decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
    2368.                                               (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
    2369.                                               (AVRational){1, avctx->sample_rate});
    2370.     ist->nb_samples = decoded_frame->nb_samples;
    2371.     err = send_frame_to_filters(ist, decoded_frame);
    2372.  
    2373.     av_frame_unref(ist->filter_frame);
    2374.     av_frame_unref(decoded_frame);
    2375.     return err < 0 ? err : ret;
    2376. }
    2377.  
    2378. static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int eof,
    2379.                         int *decode_failed)
    2380. {
    2381.     AVFrame *decoded_frame;
    2382.     int i, ret = 0, err = 0;
    2383.     int64_t best_effort_timestamp;
    2384.     int64_t dts = AV_NOPTS_VALUE;
    2385.     AVPacket avpkt;
    2386.  
    2387.     // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
    2388.     // reason. This seems like a semi-critical bug. Don't trigger EOF, and
    2389.     // skip the packet.
    2390.     if (!eof && pkt && pkt->size == 0)
    2391.         return 0;
    2392.  
    2393.     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
    2394.         return AVERROR(ENOMEM);
    2395.     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
    2396.         return AVERROR(ENOMEM);
    2397.     decoded_frame = ist->decoded_frame;
    2398.     if (ist->dts != AV_NOPTS_VALUE)
    2399.         dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
    2400.     if (pkt) {
    2401.         avpkt = *pkt;
    2402.         avpkt.dts = dts; // ffmpeg.c probably shouldn't do this
    2403.     }
    2404.  
    2405.     // The old code used to set dts on the drain packet, which does not work
    2406.     // with the new API anymore.
    2407.     if (eof) {
    2408.         void *new = av_realloc_array(ist->dts_buffer, ist->nb_dts_buffer + 1, sizeof(ist->dts_buffer[0]));
    2409.         if (!new)
    2410.             return AVERROR(ENOMEM);
    2411.         ist->dts_buffer = new;
    2412.         ist->dts_buffer[ist->nb_dts_buffer++] = dts;
    2413.     }
    2414.  
    2415.     update_benchmark(NULL);
    2416.     ret = decode(ist->dec_ctx, decoded_frame, got_output, pkt ? &avpkt : NULL);
    2417.     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
    2418.     if (ret < 0)
    2419.         *decode_failed = 1;
    2420.  
    2421.     // The following line may be required in some cases where there is no parser
    2422.     // or the parser does not has_b_frames correctly
    2423.     if (ist->st->codecpar->video_delay < ist->dec_ctx->has_b_frames) {
    2424.         if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
    2425.             ist->st->codecpar->video_delay = ist->dec_ctx->has_b_frames;
    2426.         } else
    2427.             av_log(ist->dec_ctx, AV_LOG_WARNING,
    2428.                    "video_delay is larger in decoder than demuxer %d > %d.\n"
    2429.                    "If you want to help, upload a sample "
    2430.                    "of this file to ftp://upload.ffmpeg.org/incoming/ "
    2431.                    "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
    2432.                    ist->dec_ctx->has_b_frames,
    2433.                    ist->st->codecpar->video_delay);
    2434.     }
    2435.  
    2436.     if (ret != AVERROR_EOF)
    2437.         check_decode_result(ist, got_output, ret);
    2438.  
    2439.     if (*got_output && ret >= 0) {
    2440.         if (ist->dec_ctx->width  != decoded_frame->width ||
    2441.             ist->dec_ctx->height != decoded_frame->height ||
    2442.             ist->dec_ctx->pix_fmt != decoded_frame->format) {
    2443.             av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
    2444.                 decoded_frame->width,
    2445.                 decoded_frame->height,
    2446.                 decoded_frame->format,
    2447.                 ist->dec_ctx->width,
    2448.                 ist->dec_ctx->height,
    2449.                 ist->dec_ctx->pix_fmt);
    2450.         }
    2451.     }
    2452.  
    2453.     if (!*got_output || ret < 0)
    2454.         return ret;
    2455.  
    2456.     if(ist->top_field_first>=0)
    2457.         decoded_frame->top_field_first = ist->top_field_first;
    2458.  
    2459.     ist->frames_decoded++;
    2460.  
    2461.     if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
    2462.         err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
    2463.         if (err < 0)
    2464.             goto fail;
    2465.     }
    2466.     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
    2467.  
    2468.     best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
    2469.  
    2470.     if (ist->framerate.num)
    2471.         best_effort_timestamp = ist->cfr_next_pts++;
    2472.  
    2473.     if (eof && best_effort_timestamp == AV_NOPTS_VALUE && ist->nb_dts_buffer > 0) {
    2474.         best_effort_timestamp = ist->dts_buffer[0];
    2475.  
    2476.         for (i = 0; i < ist->nb_dts_buffer - 1; i++)
    2477.             ist->dts_buffer[i] = ist->dts_buffer[i + 1];
    2478.         ist->nb_dts_buffer--;
    2479.     }
    2480.  
    2481.     if(best_effort_timestamp != AV_NOPTS_VALUE) {
    2482.         int64_t ts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
    2483.  
    2484.         if (ts != AV_NOPTS_VALUE)
    2485.             ist->next_pts = ist->pts = ts;
    2486.     }
    2487.  
    2488.     if (debug_ts) {
    2489.         av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
    2490.                "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d time_base:%d/%d\n",
    2491.                ist->st->index, av_ts2str(decoded_frame->pts),
    2492.                av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
    2493.                best_effort_timestamp,
    2494.                av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
    2495.                decoded_frame->key_frame, decoded_frame->pict_type,
    2496.                ist->st->time_base.num, ist->st->time_base.den);
    2497.     }
    2498.  
    2499.     if (ist->st->sample_aspect_ratio.num)
    2500.         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
    2501.  
    2502.     err = send_frame_to_filters(ist, decoded_frame);
    2503.  
    2504. fail:
    2505.     av_frame_unref(ist->filter_frame);
    2506.     av_frame_unref(decoded_frame);
    2507.     return err < 0 ? err : ret;
    2508. }
    2509.  
    2510. static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
    2511.                                int *decode_failed)
    2512. {
    2513.     AVSubtitle subtitle;
    2514.     int free_sub = 1;
    2515.     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
    2516.                                           &subtitle, got_output, pkt);
    2517.  
    2518.     check_decode_result(NULL, got_output, ret);
    2519.  
    2520.     if (ret < 0 || !*got_output) {
    2521.         *decode_failed = 1;
    2522.         if (!pkt->size)
    2523.             sub2video_flush(ist);
    2524.         return ret;
    2525.     }
    2526.  
    2527.     if (ist->fix_sub_duration) {
    2528.         int end = 1;
    2529.         if (ist->prev_sub.got_output) {
    2530.             end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
    2531.                              1000, AV_TIME_BASE);
    2532.             if (end < ist->prev_sub.subtitle.end_display_time) {
    2533.                 av_log(ist->dec_ctx, AV_LOG_DEBUG,
    2534.                        "Subtitle duration reduced from %"PRId32" to %d%s\n",
    2535.                        ist->prev_sub.subtitle.end_display_time, end,
    2536.                        end <= 0 ? ", dropping it" : "");
    2537.                 ist->prev_sub.subtitle.end_display_time = end;
    2538.             }
    2539.         }
    2540.         FFSWAP(int,        *got_output, ist->prev_sub.got_output);
    2541.         FFSWAP(int,        ret,         ist->prev_sub.ret);
    2542.         FFSWAP(AVSubtitle, subtitle,    ist->prev_sub.subtitle);
    2543.         if (end <= 0)
    2544.             goto out;
    2545.     }
    2546.  
    2547.     if (!*got_output)
    2548.         return ret;
    2549.  
    2550.     if (ist->sub2video.frame) {
    2551.         sub2video_update(ist, &subtitle);
    2552.     } else if (ist->nb_filters) {
    2553.         if (!ist->sub2video.sub_queue)
    2554.             ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
    2555.         if (!ist->sub2video.sub_queue)
    2556.             exit_program(1);
    2557.         if (!av_fifo_space(ist->sub2video.sub_queue)) {
    2558.             ret = av_fifo_realloc2(ist->sub2video.sub_queue, 2 * av_fifo_size(ist->sub2video.sub_queue));
    2559.             if (ret < 0)
    2560.                 exit_program(1);
    2561.         }
    2562.         av_fifo_generic_write(ist->sub2video.sub_queue, &subtitle, sizeof(subtitle), NULL);
    2563.         free_sub = 0;
    2564.     }
    2565.  
    2566.     if (!subtitle.num_rects)
    2567.         goto out;
    2568.  
    2569.     ist->frames_decoded++;
    2570.  
    2571.     for (i = 0; i < nb_output_streams; i++) {
    2572.         OutputStream *ost = output_streams[i];
    2573.  
    2574.         if (!check_output_constraints(ist, ost) || !ost->encoding_needed
    2575.             || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
    2576.             continue;
    2577.  
    2578.         do_subtitle_out(output_files[ost->file_index], ost, &subtitle);
    2579.     }
    2580.  
    2581. out:
    2582.     if (free_sub)
    2583.         avsubtitle_free(&subtitle);
    2584.     return ret;
    2585. }
    2586.  
    2587. static int send_filter_eof(InputStream *ist)
    2588. {
    2589.     int i, ret;
    2590.     for (i = 0; i < ist->nb_filters; i++) {
    2591.         ret = ifilter_send_eof(ist->filters[i]);
    2592.         if (ret < 0)
    2593.             return ret;
    2594.     }
    2595.     return 0;
    2596. }
    2597.  
    2598. /* pkt = NULL means EOF (needed to flush decoder buffers) */
    2599. static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
    2600. {
    2601.     int ret = 0, i;
    2602.     int repeating = 0;
    2603.     int eof_reached = 0;
    2604.  
    2605.     AVPacket avpkt;
    2606.     if (!ist->saw_first_ts) {
    2607.         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;
    2608.         ist->pts = 0;
    2609.         if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
    2610.             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
    2611.             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
    2612.         }
    2613.         ist->saw_first_ts = 1;
    2614.     }
    2615.  
    2616.     if (ist->next_dts == AV_NOPTS_VALUE)
    2617.         ist->next_dts = ist->dts;
    2618.     if (ist->next_pts == AV_NOPTS_VALUE)
    2619.         ist->next_pts = ist->pts;
    2620.  
    2621.     if (!pkt) {
    2622.         /* EOF handling */
    2623.         av_init_packet(&avpkt);
    2624.         avpkt.data = NULL;
    2625.         avpkt.size = 0;
    2626.     } else {
    2627.         avpkt = *pkt;
    2628.     }
    2629.  
    2630.     if (pkt && pkt->dts != AV_NOPTS_VALUE) {
    2631.         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
    2632.         if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
    2633.             ist->next_pts = ist->pts = ist->dts;
    2634.     }
    2635.  
    2636.     // while we have more to decode or while the decoder did output something on EOF
    2637.     while (ist->decoding_needed) {
    2638.         int duration = 0;
    2639.         int got_output = 0;
    2640.         int decode_failed = 0;
    2641.  
    2642.         ist->pts = ist->next_pts;
    2643.         ist->dts = ist->next_dts;
    2644.  
    2645.         switch (ist->dec_ctx->codec_type) {
    2646.         case AVMEDIA_TYPE_AUDIO:
    2647.             ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
    2648.                                    &decode_failed);
    2649.             break;
    2650.         case AVMEDIA_TYPE_VIDEO:
    2651.             ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, !pkt,
    2652.                                    &decode_failed);
    2653.             if (!repeating || !pkt || got_output) {
    2654.                 if (pkt && pkt->duration) {
    2655.                     duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
    2656.                 } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
    2657.                     int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
    2658.                     duration = ((int64_t)AV_TIME_BASE *
    2659.                                     ist->dec_ctx->framerate.den * ticks) /
    2660.                                     ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
    2661.                 }
    2662.  
    2663.                 if(ist->dts != AV_NOPTS_VALUE && duration) {
    2664.                     ist->next_dts += duration;
    2665.                 }else
    2666.                     ist->next_dts = AV_NOPTS_VALUE;
    2667.             }
    2668.  
    2669.             if (got_output)
    2670.                 ist->next_pts += duration; //FIXME the duration is not correct in some cases
    2671.             break;
    2672.         case AVMEDIA_TYPE_SUBTITLE:
    2673.             if (repeating)
    2674.                 break;
    2675.             ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
    2676.             if (!pkt && ret >= 0)
    2677.                 ret = AVERROR_EOF;
    2678.             break;
    2679.         default:
    2680.             return -1;
    2681.         }
    2682.  
    2683.         if (ret == AVERROR_EOF) {
    2684.             eof_reached = 1;
    2685.             break;
    2686.         }
    2687.  
    2688.         if (ret < 0) {
    2689.             if (decode_failed) {
    2690.                 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
    2691.                        ist->file_index, ist->st->index, av_err2str(ret));
    2692.             } else {
    2693.                 av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
    2694.                        "data for stream #%d:%d\n", ist->file_index, ist->st->index);
    2695.             }
    2696.             if (!decode_failed || exit_on_error)
    2697.                 exit_program(1);
    2698.             break;
    2699.         }
    2700.  
    2701.         if (got_output)
    2702.             ist->got_output = 1;
    2703.  
    2704.         if (!got_output)
    2705.             break;
    2706.  
    2707.         // During draining, we might get multiple output frames in this loop.
    2708.         // ffmpeg.c does not drain the filter chain on configuration changes,
    2709.         // which means if we send multiple frames at once to the filters, and
    2710.         // one of those frames changes configuration, the buffered frames will
    2711.         // be lost. This can upset certain FATE tests.
    2712.         // Decode only 1 frame per call on EOF to appease these FATE tests.
    2713.         // The ideal solution would be to rewrite decoding to use the new
    2714.         // decoding API in a better way.
    2715.         if (!pkt)
    2716.             break;
    2717.  
    2718.         repeating = 1;
    2719.     }
    2720.  
    2721.     /* after flushing, send an EOF on all the filter inputs attached to the stream */
    2722.     /* except when looping we need to flush but not to send an EOF */
    2723.     if (!pkt && ist->decoding_needed && eof_reached && !no_eof) {
    2724.         int ret = send_filter_eof(ist);
    2725.         if (ret < 0) {
    2726.             av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
    2727.             exit_program(1);
    2728.         }
    2729.     }
    2730.  
    2731.     /* handle stream copy */
    2732.     if (!ist->decoding_needed) {
    2733.         ist->dts = ist->next_dts;
    2734.         switch (ist->dec_ctx->codec_type) {
    2735.         case AVMEDIA_TYPE_AUDIO:
    2736.             if (ist->dec_ctx->sample_rate) {
    2737.                 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
    2738.                                   ist->dec_ctx->sample_rate;
    2739.             } else {
    2740.                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
    2741.             }
    2742.             break;
    2743.         case AVMEDIA_TYPE_VIDEO:
    2744.             if (ist->framerate.num) {
    2745.                 // TODO: Remove work-around for c99-to-c89 issue 7
    2746.                 AVRational time_base_q = AV_TIME_BASE_Q;
    2747.                 int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
    2748.                 ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
    2749.             } else if (pkt->duration) {
    2750.                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
    2751.             } else if(ist->dec_ctx->framerate.num != 0) {
    2752.                 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
    2753.                 ist->next_dts += ((int64_t)AV_TIME_BASE *
    2754.                                   ist->dec_ctx->framerate.den * ticks) /
    2755.                                   ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
    2756.             }
    2757.             break;
    2758.         }
    2759.         ist->pts = ist->dts;
    2760.         ist->next_pts = ist->next_dts;
    2761.     }
    2762.     for (i = 0; pkt && i < nb_output_streams; i++) {
    2763.         OutputStream *ost = output_streams[i];
    2764.  
    2765.         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
    2766.             continue;
    2767.  
    2768.         do_streamcopy(ist, ost, pkt);
    2769.     }
    2770.  
    2771.     return !eof_reached;
    2772. }
    2773.  
    2774. static void print_sdp(void)
    2775. {
    2776.     char sdp[16384];
    2777.     int i;
    2778.     int j;
    2779.     AVIOContext *sdp_pb;
    2780.     AVFormatContext **avc;
    2781.  
    2782.     for (i = 0; i < nb_output_files; i++) {
    2783.         if (!output_files[i]->header_written)
    2784.             return;
    2785.     }
    2786.  
    2787.     avc = av_malloc_array(nb_output_files, sizeof(*avc));
    2788.     if (!avc)
    2789.         exit_program(1);
    2790.     for (i = 0, j = 0; i < nb_output_files; i++) {
    2791.         if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
    2792.             avc[j] = output_files[i]->ctx;
    2793.             j++;
    2794.         }
    2795.     }
    2796.  
    2797.     if (!j)
    2798.         goto fail;
    2799.  
    2800.     av_sdp_create(avc, j, sdp, sizeof(sdp));
    2801.  
    2802.     if (!sdp_filename) {
    2803.         printf("SDP:\n%s\n", sdp);
    2804.         fflush(stdout);
    2805.     } else {
    2806.         if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
    2807.             av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
    2808.         } else {
    2809.             avio_printf(sdp_pb, "SDP:\n%s", sdp);
    2810.             avio_closep(&sdp_pb);
    2811.             av_freep(&sdp_filename);
    2812.         }
    2813.     }
    2814.  
    2815. fail:
    2816.     av_freep(&avc);
    2817. }
    2818.  
    2819. static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
    2820. {
    2821.     int i;
    2822.     for (i = 0; hwaccels[i].name; i++)
    2823.         if (hwaccels[i].pix_fmt == pix_fmt)
    2824.             return &hwaccels[i];
    2825.     return NULL;
    2826. }
    2827.  
    2828. static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
    2829. {
    2830.     InputStream *ist = s->opaque;
    2831.     const enum AVPixelFormat *p;
    2832.     int ret;
    2833.  
    2834.     for (p = pix_fmts; *p != -1; p++) {
    2835.         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
    2836.         const HWAccel *hwaccel;
    2837.  
    2838.         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
    2839.             break;
    2840.  
    2841.         hwaccel = get_hwaccel(*p);
    2842.         if (!hwaccel ||
    2843.             (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
    2844.             (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
    2845.             continue;
    2846.  
    2847.         ret = hwaccel->init(s);
    2848.         if (ret < 0) {
    2849.             if (ist->hwaccel_id == hwaccel->id) {
    2850.                 av_log(NULL, AV_LOG_FATAL,
    2851.                        "%s hwaccel requested for input stream #%d:%d, "
    2852.                        "but cannot be initialized.\n", hwaccel->name,
    2853.                        ist->file_index, ist->st->index);
    2854.                 return AV_PIX_FMT_NONE;
    2855.             }
    2856.             continue;
    2857.         }
    2858.  
    2859.         if (ist->hw_frames_ctx) {
    2860.             s->hw_frames_ctx = av_buffer_ref(ist->hw_frames_ctx);
    2861.             if (!s->hw_frames_ctx)
    2862.                 return AV_PIX_FMT_NONE;
    2863.         }
    2864.  
    2865.         ist->active_hwaccel_id = hwaccel->id;
    2866.         ist->hwaccel_pix_fmt   = *p;
    2867.         break;
    2868.     }
    2869.  
    2870.     return *p;
    2871. }
    2872.  
    2873. static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
    2874. {
    2875.     InputStream *ist = s->opaque;
    2876.  
    2877.     if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
    2878.         return ist->hwaccel_get_buffer(s, frame, flags);
    2879.  
    2880.     return avcodec_default_get_buffer2(s, frame, flags);
    2881. }
    2882.  
    2883. static int init_input_stream(int ist_index, char *error, int error_len)
    2884. {
    2885.     int ret;
    2886.     InputStream *ist = input_streams[ist_index];
    2887.  
    2888.     if (ist->decoding_needed) {
    2889.         AVCodec *codec = ist->dec;
    2890.         if (!codec) {
    2891.             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
    2892.                     avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
    2893.             return AVERROR(EINVAL);
    2894.         }
    2895.  
    2896.         ist->dec_ctx->opaque                = ist;
    2897.         ist->dec_ctx->get_format            = get_format;
    2898.         ist->dec_ctx->get_buffer2           = get_buffer;
    2899.         ist->dec_ctx->thread_safe_callbacks = 1;
    2900.  
    2901.         av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
    2902.         if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
    2903.            (ist->decoding_needed & DECODING_FOR_OST)) {
    2904.             av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
    2905.             if (ist->decoding_needed & DECODING_FOR_FILTER)
    2906.                 av_log(NULL, AV_LOG_WARNING, "Warning using DVB subtitles for filtering and output at the same time is not fully supported, also see -compute_edt [0|1]\n");
    2907.         }
    2908.  
    2909.         av_dict_set(&ist->decoder_opts, "sub_text_format", "ass", AV_DICT_DONT_OVERWRITE);
    2910.  
    2911.         /* Useful for subtitles retiming by lavf (FIXME), skipping samples in
    2912.          * audio, and video decoders such as cuvid or mediacodec */
    2913.         av_codec_set_pkt_timebase(ist->dec_ctx, ist->st->time_base);
    2914.  
    2915.         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
    2916.             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
    2917.         if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
    2918.             if (ret == AVERROR_EXPERIMENTAL)
    2919.                 abort_codec_experimental(codec, 0);
    2920.  
    2921.             snprintf(error, error_len,
    2922.                      "Error while opening decoder for input stream "
    2923.                      "#%d:%d : %s",
    2924.                      ist->file_index, ist->st->index, av_err2str(ret));
    2925.             return ret;
    2926.         }
    2927.         assert_avoptions(ist->decoder_opts);
    2928.     }
    2929.  
    2930.     ist->next_pts = AV_NOPTS_VALUE;
    2931.     ist->next_dts = AV_NOPTS_VALUE;
    2932.  
    2933.     return 0;
    2934. }
    2935.  
    2936. static InputStream *get_input_stream(OutputStream *ost)
    2937. {
    2938.     if (ost->source_index >= 0)
    2939.         return input_streams[ost->source_index];
    2940.     return NULL;
    2941. }
    2942.  
    2943. static int compare_int64(const void *a, const void *b)
    2944. {
    2945.     return FFDIFFSIGN(*(const int64_t *)a, *(const int64_t *)b);
    2946. }
    2947.  
    2948. /* open the muxer when all the streams are initialized */
    2949. static int check_init_output_file(OutputFile *of, int file_index)
    2950. {
    2951.     int ret, i;
    2952.  
    2953.     for (i = 0; i < of->ctx->nb_streams; i++) {
    2954.         OutputStream *ost = output_streams[of->ost_index + i];
    2955.         if (!ost->initialized)
    2956.             return 0;
    2957.     }
    2958.  
    2959.     of->ctx->interrupt_callback = int_cb;
    2960.  
    2961.     ret = avformat_write_header(of->ctx, &of->opts);
    2962.     if (ret < 0) {
    2963.         av_log(NULL, AV_LOG_ERROR,
    2964.                "Could not write header for output file #%d "
    2965.                "(incorrect codec parameters ?): %s\n",
    2966.                file_index, av_err2str(ret));
    2967.         return ret;
    2968.     }
    2969.     //assert_avoptions(of->opts);
    2970.     of->header_written = 1;
    2971.  
    2972.     av_dump_format(of->ctx, file_index, of->ctx->filename, 1);
    2973.  
    2974.     if (sdp_filename || want_sdp)
    2975.         print_sdp();
    2976.  
    2977.     /* flush the muxing queues */
    2978.     for (i = 0; i < of->ctx->nb_streams; i++) {
    2979.         OutputStream *ost = output_streams[of->ost_index + i];
    2980.  
    2981.         /* try to improve muxing time_base (only possible if nothing has been written yet) */
    2982.         if (!av_fifo_size(ost->muxing_queue))
    2983.             ost->mux_timebase = ost->st->time_base;
    2984.  
    2985.         while (av_fifo_size(ost->muxing_queue)) {
    2986.             AVPacket pkt;
    2987.             av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
    2988.             write_packet(of, &pkt, ost, 1);
    2989.         }
    2990.     }
    2991.  
    2992.     return 0;
    2993. }
    2994.  
    2995. static int init_output_bsfs(OutputStream *ost)
    2996. {
    2997.     AVBSFContext *ctx;
    2998.     int i, ret;
    2999.  
    3000.     if (!ost->nb_bitstream_filters)
    3001.         return 0;
    3002.  
    3003.     for (i = 0; i < ost->nb_bitstream_filters; i++) {
    3004.         ctx = ost->bsf_ctx[i];
    3005.  
    3006.         ret = avcodec_parameters_copy(ctx->par_in,
    3007.                                       i ? ost->bsf_ctx[i - 1]->par_out : ost->st->codecpar);
    3008.         if (ret < 0)
    3009.             return ret;
    3010.  
    3011.         ctx->time_base_in = i ? ost->bsf_ctx[i - 1]->time_base_out : ost->st->time_base;
    3012.  
    3013.         ret = av_bsf_init(ctx);
    3014.         if (ret < 0) {
    3015.             av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
    3016.                    ost->bsf_ctx[i]->filter->name);
    3017.             return ret;
    3018.         }
    3019.     }
    3020.  
    3021.     ctx = ost->bsf_ctx[ost->nb_bitstream_filters - 1];
    3022.     ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
    3023.     if (ret < 0)
    3024.         return ret;
    3025.  
    3026.     ost->st->time_base = ctx->time_base_out;
    3027.  
    3028.     return 0;
    3029. }
    3030.  
    3031. static int init_output_stream_streamcopy(OutputStream *ost)
    3032. {
    3033.     OutputFile *of = output_files[ost->file_index];
    3034.     InputStream *ist = get_input_stream(ost);
    3035.     AVCodecParameters *par_dst = ost->st->codecpar;
    3036.     AVCodecParameters *par_src = ost->ref_par;
    3037.     AVRational sar;
    3038.     int i, ret;
    3039.     uint32_t codec_tag = par_dst->codec_tag;
    3040.  
    3041.     av_assert0(ist && !ost->filter);
    3042.  
    3043.     ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
    3044.     if (ret >= 0)
    3045.         ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
    3046.     if (ret < 0) {
    3047.         av_log(NULL, AV_LOG_FATAL,
    3048.                "Error setting up codec context options.\n");
    3049.         return ret;
    3050.     }
    3051.     avcodec_parameters_from_context(par_src, ost->enc_ctx);
    3052.  
    3053.     if (!codec_tag) {
    3054.         unsigned int codec_tag_tmp;
    3055.         if (!of->ctx->oformat->codec_tag ||
    3056.             av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
    3057.             !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag_tmp))
    3058.             codec_tag = par_src->codec_tag;
    3059.     }
    3060.  
    3061.     ret = avcodec_parameters_copy(par_dst, par_src);
    3062.     if (ret < 0)
    3063.         return ret;
    3064.  
    3065.     par_dst->codec_tag = codec_tag;
    3066.  
    3067.     if (!ost->frame_rate.num)
    3068.         ost->frame_rate = ist->framerate;
    3069.     ost->st->avg_frame_rate = ost->frame_rate;
    3070.  
    3071.     ret = avformat_transfer_internal_stream_timing_info(of->ctx->oformat, ost->st, ist->st, copy_tb);
    3072.     if (ret < 0)
    3073.         return ret;
    3074.  
    3075.     // copy timebase while removing common factors
    3076.     if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
    3077.         ost->st->time_base = av_add_q(av_stream_get_codec_timebase(ost->st), (AVRational){0, 1});
    3078.  
    3079.     // copy estimated duration as a hint to the muxer
    3080.     if (ost->st->duration <= 0 && ist->st->duration > 0)
    3081.         ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
    3082.  
    3083.     // copy disposition
    3084.     ost->st->disposition = ist->st->disposition;
    3085.  
    3086.     if (ist->st->nb_side_data) {
    3087.         ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
    3088.                                               sizeof(*ist->st->side_data));
    3089.         if (!ost->st->side_data)
    3090.             return AVERROR(ENOMEM);
    3091.  
    3092.         ost->st->nb_side_data = 0;
    3093.         for (i = 0; i < ist->st->nb_side_data; i++) {
    3094.             const AVPacketSideData *sd_src = &ist->st->side_data[i];
    3095.             AVPacketSideData *sd_dst = &ost->st->side_data[ost->st->nb_side_data];
    3096.  
    3097.             sd_dst->data = av_malloc(sd_src->size);
    3098.             if (!sd_dst->data)
    3099.                 return AVERROR(ENOMEM);
    3100.             memcpy(sd_dst->data, sd_src->data, sd_src->size);
    3101.             sd_dst->size = sd_src->size;
    3102.             sd_dst->type = sd_src->type;
    3103.             ost->st->nb_side_data++;
    3104.         }
    3105.     }
    3106.  
    3107.     if (ost->rotate_overridden) {
    3108.         uint8_t *sd = av_stream_new_side_data(ost->st, AV_PKT_DATA_DISPLAYMATRIX,
    3109.                                               sizeof(int32_t) * 9);
    3110.         if (sd)
    3111.             av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
    3112.     }
    3113.  
    3114.     ost->parser = av_parser_init(par_dst->codec_id);
    3115.     ost->parser_avctx = avcodec_alloc_context3(NULL);
    3116.     if (!ost->parser_avctx)
    3117.         return AVERROR(ENOMEM);
    3118.  
    3119.     switch (par_dst->codec_type) {
    3120.     case AVMEDIA_TYPE_AUDIO:
    3121.         if (audio_volume != 256) {
    3122.             av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
    3123.             exit_program(1);
    3124.         }
    3125.         if((par_dst->block_align == 1 || par_dst->block_align == 1152 || par_dst->block_align == 576) && par_dst->codec_id == AV_CODEC_ID_MP3)
    3126.             par_dst->block_align= 0;
    3127.         if(par_dst->codec_id == AV_CODEC_ID_AC3)
    3128.             par_dst->block_align= 0;
    3129.         break;
    3130.     case AVMEDIA_TYPE_VIDEO:
    3131.         if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
    3132.             sar =
    3133.                 av_mul_q(ost->frame_aspect_ratio,
    3134.                          (AVRational){ par_dst->height, par_dst->width });
    3135.             av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
    3136.                    "with stream copy may produce invalid files\n");
    3137.             }
    3138.         else if (ist->st->sample_aspect_ratio.num)
    3139.             sar = ist->st->sample_aspect_ratio;
    3140.         else
    3141.             sar = par_src->sample_aspect_ratio;
    3142.         ost->st->sample_aspect_ratio = par_dst->sample_aspect_ratio = sar;
    3143.         ost->st->avg_frame_rate = ist->st->avg_frame_rate;
    3144.         ost->st->r_frame_rate = ist->st->r_frame_rate;
    3145.         break;
    3146.     }
    3147.  
    3148.     ost->mux_timebase = ist->st->time_base;
    3149.  
    3150.     return 0;
    3151. }
    3152.  
    3153. static void set_encoder_id(OutputFile *of, OutputStream *ost)
    3154. {
    3155.     AVDictionaryEntry *e;
    3156.  
    3157.     uint8_t *encoder_string;
    3158.     int encoder_string_len;
    3159.     int format_flags = 0;
    3160.     int codec_flags = 0;
    3161.  
    3162.     if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
    3163.         return;
    3164.  
    3165.     e = av_dict_get(of->opts, "fflags", NULL, 0);
    3166.     if (e) {
    3167.         const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
    3168.         if (!o)
    3169.             return;
    3170.         av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
    3171.     }
    3172.     e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
    3173.     if (e) {
    3174.         const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
    3175.         if (!o)
    3176.             return;
    3177.         av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
    3178.     }
    3179.  
    3180.     encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
    3181.     encoder_string     = av_mallocz(encoder_string_len);
    3182.     if (!encoder_string)
    3183.         exit_program(1);
    3184.  
    3185.     if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
    3186.         av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
    3187.     else
    3188.         av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
    3189.     av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
    3190.     av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
    3191.                 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
    3192. }
    3193.  
    3194. static void parse_forced_key_frames(char *kf, OutputStream *ost,
    3195.                                     AVCodecContext *avctx)
    3196. {
    3197.     char *p;
    3198.     int n = 1, i, size, index = 0;
    3199.     int64_t t, *pts;
    3200.  
    3201.     for (p = kf; *p; p++)
    3202.         if (*p == ',')
    3203.             n++;
    3204.     size = n;
    3205.     pts = av_malloc_array(size, sizeof(*pts));
    3206.     if (!pts) {
    3207.         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
    3208.         exit_program(1);
    3209.     }
    3210.  
    3211.     p = kf;
    3212.     for (i = 0; i < n; i++) {
    3213.         char *next = strchr(p, ',');
    3214.  
    3215.         if (next)
    3216.             *next++ = 0;
    3217.  
    3218.         if (!memcmp(p, "chapters", 8)) {
    3219.  
    3220.             AVFormatContext *avf = output_files[ost->file_index]->ctx;
    3221.             int j;
    3222.  
    3223.             if (avf->nb_chapters > INT_MAX - size ||
    3224.                 !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
    3225.                                      sizeof(*pts)))) {
    3226.                 av_log(NULL, AV_LOG_FATAL,
    3227.                        "Could not allocate forced key frames array.\n");
    3228.                 exit_program(1);
    3229.             }
    3230.             t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
    3231.             t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
    3232.  
    3233.             for (j = 0; j < avf->nb_chapters; j++) {
    3234.                 AVChapter *c = avf->chapters[j];
    3235.                 av_assert1(index < size);
    3236.                 pts[index++] = av_rescale_q(c->start, c->time_base,
    3237.                                             avctx->time_base) + t;
    3238.             }
    3239.  
    3240.         } else {
    3241.  
    3242.             t = parse_time_or_die("force_key_frames", p, 1);
    3243.             av_assert1(index < size);
    3244.             pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
    3245.  
    3246.         }
    3247.  
    3248.         p = next;
    3249.     }
    3250.  
    3251.     av_assert0(index == size);
    3252.     qsort(pts, size, sizeof(*pts), compare_int64);
    3253.     ost->forced_kf_count = size;
    3254.     ost->forced_kf_pts   = pts;
    3255. }
    3256.  
    3257. static int init_output_stream_encode(OutputStream *ost)
    3258. {
    3259.     InputStream *ist = get_input_stream(ost);
    3260.     AVCodecContext *enc_ctx = ost->enc_ctx;
    3261.     AVCodecContext *dec_ctx = NULL;
    3262.     AVFormatContext *oc = output_files[ost->file_index]->ctx;
    3263.     int j, ret;
    3264.  
    3265.     set_encoder_id(output_files[ost->file_index], ost);
    3266.  
    3267.     // Muxers use AV_PKT_DATA_DISPLAYMATRIX to signal rotation. On the other
    3268.     // hand, the legacy API makes demuxers set "rotate" metadata entries,
    3269.     // which have to be filtered out to prevent leaking them to output files.
    3270.     av_dict_set(&ost->st->metadata, "rotate", NULL, 0);
    3271.  
    3272.     if (ist) {
    3273.         ost->st->disposition          = ist->st->disposition;
    3274.  
    3275.         dec_ctx = ist->dec_ctx;
    3276.  
    3277.         enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
    3278.     } else {
    3279.         for (j = 0; j < oc->nb_streams; j++) {
    3280.             AVStream *st = oc->streams[j];
    3281.             if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
    3282.                 break;
    3283.         }
    3284.         if (j == oc->nb_streams)
    3285.             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
    3286.                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
    3287.                 ost->st->disposition = AV_DISPOSITION_DEFAULT;
    3288.     }
    3289.  
    3290.     if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
    3291.         if (!ost->frame_rate.num)
    3292.             ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
    3293.         if (ist && !ost->frame_rate.num)
    3294.             ost->frame_rate = ist->framerate;
    3295.         if (ist && !ost->frame_rate.num)
    3296.             ost->frame_rate = ist->st->r_frame_rate;
    3297.         if (ist && !ost->frame_rate.num) {
    3298.             ost->frame_rate = (AVRational){25, 1};
    3299.             av_log(NULL, AV_LOG_WARNING,
    3300.                    "No information "
    3301.                    "about the input framerate is available. Falling "
    3302.                    "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
    3303.                    "if you want a different framerate.\n",
    3304.                    ost->file_index, ost->index);
    3305.         }
    3306. //      ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
    3307.         if (ost->enc->supported_framerates && !ost->force_fps) {
    3308.             int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
    3309.             ost->frame_rate = ost->enc->supported_framerates[idx];
    3310.         }
    3311.         // reduce frame rate for mpeg4 to be within the spec limits
    3312.         if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
    3313.             av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
    3314.                       ost->frame_rate.num, ost->frame_rate.den, 65535);
    3315.         }
    3316.     }
    3317.  
    3318.     switch (enc_ctx->codec_type) {
    3319.     case AVMEDIA_TYPE_AUDIO:
    3320.         enc_ctx->sample_fmt     = av_buffersink_get_format(ost->filter->filter);
    3321.         if (dec_ctx)
    3322.             enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
    3323.                                                  av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
    3324.         enc_ctx->sample_rate    = av_buffersink_get_sample_rate(ost->filter->filter);
    3325.         enc_ctx->channel_layout = av_buffersink_get_channel_layout(ost->filter->filter);
    3326.         enc_ctx->channels       = av_buffersink_get_channels(ost->filter->filter);
    3327.         enc_ctx->time_base      = (AVRational){ 1, enc_ctx->sample_rate };
    3328.         break;
    3329.     case AVMEDIA_TYPE_VIDEO:
    3330.         enc_ctx->time_base = av_inv_q(ost->frame_rate);
    3331.         if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
    3332.             enc_ctx->time_base = av_buffersink_get_time_base(ost->filter->filter);
    3333.         if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
    3334.            && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
    3335.             av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
    3336.                                        "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
    3337.         }
    3338.         for (j = 0; j < ost->forced_kf_count; j++)
    3339.             ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
    3340.                                                  AV_TIME_BASE_Q,
    3341.                                                  enc_ctx->time_base);
    3342.  
    3343.         enc_ctx->width  = av_buffersink_get_w(ost->filter->filter);
    3344.         enc_ctx->height = av_buffersink_get_h(ost->filter->filter);
    3345.         enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
    3346.             ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
    3347.             av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
    3348.             av_buffersink_get_sample_aspect_ratio(ost->filter->filter);
    3349.         if (!strncmp(ost->enc->name, "libx264", 7) &&
    3350.             enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
    3351.             av_buffersink_get_format(ost->filter->filter) != AV_PIX_FMT_YUV420P)
    3352.             av_log(NULL, AV_LOG_WARNING,
    3353.                    "No pixel format specified, %s for H.264 encoding chosen.\n"
    3354.                    "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
    3355.                    av_get_pix_fmt_name(av_buffersink_get_format(ost->filter->filter)));
    3356.         if (!strncmp(ost->enc->name, "mpeg2video", 10) &&
    3357.             enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
    3358.             av_buffersink_get_format(ost->filter->filter) != AV_PIX_FMT_YUV420P)
    3359.             av_log(NULL, AV_LOG_WARNING,
    3360.                    "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
    3361.                    "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
    3362.                    av_get_pix_fmt_name(av_buffersink_get_format(ost->filter->filter)));
    3363.         enc_ctx->pix_fmt = av_buffersink_get_format(ost->filter->filter);
    3364.         if (dec_ctx)
    3365.             enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
    3366.                                                  av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
    3367.  
    3368.         enc_ctx->framerate = ost->frame_rate;
    3369.  
    3370.         ost->st->avg_frame_rate = ost->frame_rate;
    3371.  
    3372.         if (!dec_ctx ||
    3373.             enc_ctx->width   != dec_ctx->width  ||
    3374.             enc_ctx->height  != dec_ctx->height ||
    3375.             enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
    3376.             enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
    3377.         }
    3378.  
    3379.         if (ost->forced_keyframes) {
    3380.             if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
    3381.                 ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
    3382.                                     forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
    3383.                 if (ret < 0) {
    3384.                     av_log(NULL, AV_LOG_ERROR,
    3385.                            "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
    3386.                     return ret;
    3387.                 }
    3388.                 ost->forced_keyframes_expr_const_values[FKF_N] = 0;
    3389.                 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
    3390.                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
    3391.                 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
    3392.  
    3393.             // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
    3394.             // parse it only for static kf timings
    3395.             } else if(strncmp(ost->forced_keyframes, "source", 6)) {
    3396.                 parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
    3397.             }
    3398.         }
    3399.         break;
    3400.     case AVMEDIA_TYPE_SUBTITLE:
    3401.         enc_ctx->time_base = AV_TIME_BASE_Q;
    3402.         if (!enc_ctx->width) {
    3403.             enc_ctx->width     = input_streams[ost->source_index]->st->codecpar->width;
    3404.             enc_ctx->height    = input_streams[ost->source_index]->st->codecpar->height;
    3405.         }
    3406.         break;
    3407.     case AVMEDIA_TYPE_DATA:
    3408.         break;
    3409.     default:
    3410.         abort();
    3411.         break;
    3412.     }
    3413.  
    3414.     ost->mux_timebase = enc_ctx->time_base;
    3415.  
    3416.     return 0;
    3417. }
    3418.  
    3419. static int init_output_stream(OutputStream *ost, char *error, int error_len)
    3420. {
    3421.     int ret = 0;
    3422.  
    3423.     if (ost->encoding_needed) {
    3424.         AVCodec      *codec = ost->enc;
    3425.         AVCodecContext *dec = NULL;
    3426.         InputStream *ist;
    3427.  
    3428.         ret = init_output_stream_encode(ost);
    3429.         if (ret < 0)
    3430.             return ret;
    3431.  
    3432.         if ((ist = get_input_stream(ost)))
    3433.             dec = ist->dec_ctx;
    3434.         if (dec && dec->subtitle_header) {
    3435.             /* ASS code assumes this buffer is null terminated so add extra byte. */
    3436.             ost->enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
    3437.             if (!ost->enc_ctx->subtitle_header)
    3438.                 return AVERROR(ENOMEM);
    3439.             memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
    3440.             ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
    3441.         }
    3442.         if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
    3443.             av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
    3444.         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
    3445.             !codec->defaults &&
    3446.             !av_dict_get(ost->encoder_opts, "b", NULL, 0) &&
    3447.             !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
    3448.             av_dict_set(&ost->encoder_opts, "b", "128000", 0);
    3449.  
    3450.         if (ost->filter && av_buffersink_get_hw_frames_ctx(ost->filter->filter) &&
    3451.             ((AVHWFramesContext*)av_buffersink_get_hw_frames_ctx(ost->filter->filter)->data)->format ==
    3452.             av_buffersink_get_format(ost->filter->filter)) {
    3453.             ost->enc_ctx->hw_frames_ctx = av_buffer_ref(av_buffersink_get_hw_frames_ctx(ost->filter->filter));
    3454.             if (!ost->enc_ctx->hw_frames_ctx)
    3455.                 return AVERROR(ENOMEM);
    3456.         }
    3457.  
    3458.         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
    3459.             if (ret == AVERROR_EXPERIMENTAL)
    3460.                 abort_codec_experimental(codec, 1);
    3461.             snprintf(error, error_len,
    3462.                      "Error while opening encoder for output stream #%d:%d - "
    3463.                      "maybe incorrect parameters such as bit_rate, rate, width or height",
    3464.                     ost->file_index, ost->index);
    3465.             return ret;
    3466.         }
    3467.         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
    3468.             !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
    3469.             av_buffersink_set_frame_size(ost->filter->filter,
    3470.                                             ost->enc_ctx->frame_size);
    3471.         assert_avoptions(ost->encoder_opts);
    3472.         if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
    3473.             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
    3474.                                          " It takes bits/s as argument, not kbits/s\n");
    3475.  
    3476.         ret = avcodec_parameters_from_context(ost->st->codecpar, ost->enc_ctx);
    3477.         if (ret < 0) {
    3478.             av_log(NULL, AV_LOG_FATAL,
    3479.                    "Error initializing the output stream codec context.\n");
    3480.             exit_program(1);
    3481.         }
    3482.         /*
    3483.          * FIXME: ost->st->codec should't be needed here anymore.
    3484.          */
    3485.         ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
    3486.         if (ret < 0)
    3487.             return ret;
    3488.  
    3489.         if (ost->enc_ctx->nb_coded_side_data) {
    3490.             int i;
    3491.  
    3492.             ost->st->side_data = av_realloc_array(NULL, ost->enc_ctx->nb_coded_side_data,
    3493.                                                   sizeof(*ost->st->side_data));
    3494.             if (!ost->st->side_data)
    3495.                 return AVERROR(ENOMEM);
    3496.  
    3497.             for (i = 0; i < ost->enc_ctx->nb_coded_side_data; i++) {
    3498.                 const AVPacketSideData *sd_src = &ost->enc_ctx->coded_side_data[i];
    3499.                 AVPacketSideData *sd_dst = &ost->st->side_data[i];
    3500.  
    3501.                 sd_dst->data = av_malloc(sd_src->size);
    3502.                 if (!sd_dst->data)
    3503.                     return AVERROR(ENOMEM);
    3504.                 memcpy(sd_dst->data, sd_src->data, sd_src->size);
    3505.                 sd_dst->size = sd_src->size;
    3506.                 sd_dst->type = sd_src->type;
    3507.                 ost->st->nb_side_data++;
    3508.             }
    3509.         }
    3510.  
    3511.         /*
    3512.          * Add global input side data. For now this is naive, and copies it
    3513.          * from the input stream's global side data. All side data should
    3514.          * really be funneled over AVFrame and libavfilter, then added back to
    3515.          * packet side data, and then potentially using the first packet for
    3516.          * global side data.
    3517.          */
    3518.         if (ist) {
    3519.             int i;
    3520.             for (i = 0; i < ist->st->nb_side_data; i++) {
    3521.                 AVPacketSideData *sd = &ist->st->side_data[i];
    3522.                 uint8_t *dst = av_stream_new_side_data(ost->st, sd->type, sd->size);
    3523.                 if (!dst)
    3524.                     return AVERROR(ENOMEM);
    3525.                 memcpy(dst, sd->data, sd->size);
    3526.                 if (ist->autorotate && sd->type == AV_PKT_DATA_DISPLAYMATRIX)
    3527.                     av_display_rotation_set((uint32_t *)dst, 0);
    3528.             }
    3529.         }
    3530.  
    3531.         // copy timebase while removing common factors
    3532.         if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
    3533.             ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
    3534.  
    3535.         // copy estimated duration as a hint to the muxer
    3536.         if (ost->st->duration <= 0 && ist && ist->st->duration > 0)
    3537.             ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
    3538.  
    3539.         ost->st->codec->codec= ost->enc_ctx->codec;
    3540.     } else if (ost->stream_copy) {
    3541.         ret = init_output_stream_streamcopy(ost);
    3542.         if (ret < 0)
    3543.             return ret;
    3544.  
    3545.         /*
    3546.          * FIXME: will the codec context used by the parser during streamcopy
    3547.          * This should go away with the new parser API.
    3548.          */
    3549.         ret = avcodec_parameters_to_context(ost->parser_avctx, ost->st->codecpar);
    3550.         if (ret < 0)
    3551.             return ret;
    3552.     }
    3553.  
    3554.     // parse user provided disposition, and update stream values
    3555.     if (ost->disposition) {
    3556.         static const AVOption opts[] = {
    3557.             { "disposition"         , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
    3558.             { "default"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "flags" },
    3559.             { "dub"                 , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "flags" },
    3560.             { "original"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL          },    .unit = "flags" },
    3561.             { "comment"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT           },    .unit = "flags" },
    3562.             { "lyrics"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS            },    .unit = "flags" },
    3563.             { "karaoke"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE           },    .unit = "flags" },
    3564.             { "forced"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED            },    .unit = "flags" },
    3565.             { "hearing_impaired"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "flags" },
    3566.             { "visual_impaired"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "flags" },
    3567.             { "clean_effects"       , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "flags" },
    3568.             { "captions"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "flags" },
    3569.             { "descriptions"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "flags" },
    3570.             { "metadata"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "flags" },
    3571.             { NULL },
    3572.         };
    3573.         static const AVClass class = {
    3574.             .class_name = "",
    3575.             .item_name  = av_default_item_name,
    3576.             .option     = opts,
    3577.             .version    = LIBAVUTIL_VERSION_INT,
    3578.         };
    3579.         const AVClass *pclass = &class;
    3580.  
    3581.         ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
    3582.         if (ret < 0)
    3583.             return ret;
    3584.     }
    3585.  
    3586.     /* initialize bitstream filters for the output stream
    3587.      * needs to be done here, because the codec id for streamcopy is not
    3588.      * known until now */
    3589.     ret = init_output_bsfs(ost);
    3590.     if (ret < 0)
    3591.         return ret;
    3592.  
    3593.     ost->initialized = 1;
    3594.  
    3595.     ret = check_init_output_file(output_files[ost->file_index], ost->file_index);
    3596.     if (ret < 0)
    3597.         return ret;
    3598.  
    3599.     return ret;
    3600. }
    3601.  
    3602. static void report_new_stream(int input_index, AVPacket *pkt)
    3603. {
    3604.     InputFile *file = input_files[input_index];
    3605.     AVStream *st = file->ctx->streams[pkt->stream_index];
    3606.  
    3607.     if (pkt->stream_index < file->nb_streams_warn)
    3608.         return;
    3609.     av_log(file->ctx, AV_LOG_WARNING,
    3610.            "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
    3611.            av_get_media_type_string(st->codecpar->codec_type),
    3612.            input_index, pkt->stream_index,
    3613.            pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
    3614.     file->nb_streams_warn = pkt->stream_index + 1;
    3615. }
    3616.  
    3617. static int transcode_init(void)
    3618. {
    3619.     int ret = 0, i, j, k;
    3620.     AVFormatContext *oc;
    3621.     OutputStream *ost;
    3622.     InputStream *ist;
    3623.     char error[1024] = {0};
    3624.  
    3625.     for (i = 0; i < nb_filtergraphs; i++) {
    3626.         FilterGraph *fg = filtergraphs[i];
    3627.         for (j = 0; j < fg->nb_outputs; j++) {
    3628.             OutputFilter *ofilter = fg->outputs[j];
    3629.             if (!ofilter->ost || ofilter->ost->source_index >= 0)
    3630.                 continue;
    3631.             if (fg->nb_inputs != 1)
    3632.                 continue;
    3633.             for (k = nb_input_streams-1; k >= 0 ; k--)
    3634.                 if (fg->inputs[0]->ist == input_streams[k])
    3635.                     break;
    3636.             ofilter->ost->source_index = k;
    3637.         }
    3638.     }
    3639.  
    3640.     /* init framerate emulation */
    3641.     for (i = 0; i < nb_input_files; i++) {
    3642.         InputFile *ifile = input_files[i];
    3643.         if (ifile->rate_emu)
    3644.             for (j = 0; j < ifile->nb_streams; j++)
    3645.                 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
    3646.     }
    3647.  
    3648.     /* init input streams */
    3649.     for (i = 0; i < nb_input_streams; i++)
    3650.         if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
    3651.             for (i = 0; i < nb_output_streams; i++) {
    3652.                 ost = output_streams[i];
    3653.                 avcodec_close(ost->enc_ctx);
    3654.             }
    3655.             goto dump_format;
    3656.         }
    3657.  
    3658.     /* open each encoder */
    3659.     for (i = 0; i < nb_output_streams; i++) {
    3660.         // skip streams fed from filtergraphs until we have a frame for them
    3661.         if (output_streams[i]->filter)
    3662.             continue;
    3663.  
    3664.         ret = init_output_stream(output_streams[i], error, sizeof(error));
    3665.         if (ret < 0)
    3666.             goto dump_format;
    3667.     }
    3668.  
    3669.     /* discard unused programs */
    3670.     for (i = 0; i < nb_input_files; i++) {
    3671.         InputFile *ifile = input_files[i];
    3672.         for (j = 0; j < ifile->ctx->nb_programs; j++) {
    3673.             AVProgram *p = ifile->ctx->programs[j];
    3674.             int discard  = AVDISCARD_ALL;
    3675.  
    3676.             for (k = 0; k < p->nb_stream_indexes; k++)
    3677.                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
    3678.                     discard = AVDISCARD_DEFAULT;
    3679.                     break;
    3680.                 }
    3681.             p->discard = discard;
    3682.         }
    3683.     }
    3684.  
    3685.     /* write headers for files with no streams */
    3686.     for (i = 0; i < nb_output_files; i++) {
    3687.         oc = output_files[i]->ctx;
    3688.         if (oc->oformat->flags & AVFMT_NOSTREAMS && oc->nb_streams == 0) {
    3689.             ret = check_init_output_file(output_files[i], i);
    3690.             if (ret < 0)
    3691.                 goto dump_format;
    3692.         }
    3693.     }
    3694.  
    3695.  dump_format:
    3696.     /* dump the stream mapping */
    3697.     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
    3698.     for (i = 0; i < nb_input_streams; i++) {
    3699.         ist = input_streams[i];
    3700.  
    3701.         for (j = 0; j < ist->nb_filters; j++) {
    3702.             if (!filtergraph_is_simple(ist->filters[j]->graph)) {
    3703.                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
    3704.                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
    3705.                        ist->filters[j]->name);
    3706.                 if (nb_filtergraphs > 1)
    3707.                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
    3708.                 av_log(NULL, AV_LOG_INFO, "\n");
    3709.             }
    3710.         }
    3711.     }
    3712.  
    3713.     for (i = 0; i < nb_output_streams; i++) {
    3714.         ost = output_streams[i];
    3715.  
    3716.         if (ost->attachment_filename) {
    3717.             /* an attached file */
    3718.             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
    3719.                    ost->attachment_filename, ost->file_index, ost->index);
    3720.             continue;
    3721.         }
    3722.  
    3723.         if (ost->filter && !filtergraph_is_simple(ost->filter->graph)) {
    3724.             /* output from a complex graph */
    3725.             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
    3726.             if (nb_filtergraphs > 1)
    3727.                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
    3728.  
    3729.             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
    3730.                    ost->index, ost->enc ? ost->enc->name : "?");
    3731.             continue;
    3732.         }
    3733.  
    3734.         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
    3735.                input_streams[ost->source_index]->file_index,
    3736.                input_streams[ost->source_index]->st->index,
    3737.                ost->file_index,
    3738.                ost->index);
    3739.         if (ost->sync_ist != input_streams[ost->source_index])
    3740.             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
    3741.                    ost->sync_ist->file_index,
    3742.                    ost->sync_ist->st->index);
    3743.         if (ost->stream_copy)
    3744.             av_log(NULL, AV_LOG_INFO, " (copy)");
    3745.         else {
    3746.             const AVCodec *in_codec    = input_streams[ost->source_index]->dec;
    3747.             const AVCodec *out_codec   = ost->enc;
    3748.             const char *decoder_name   = "?";
    3749.             const char *in_codec_name  = "?";
    3750.             const char *encoder_name   = "?";
    3751.             const char *out_codec_name = "?";
    3752.             const AVCodecDescriptor *desc;
    3753.  
    3754.             if (in_codec) {
    3755.                 decoder_name  = in_codec->name;
    3756.                 desc = avcodec_descriptor_get(in_codec->id);
    3757.                 if (desc)
    3758.                     in_codec_name = desc->name;
    3759.                 if (!strcmp(decoder_name, in_codec_name))
    3760.                     decoder_name = "native";
    3761.             }
    3762.  
    3763.             if (out_codec) {
    3764.                 encoder_name   = out_codec->name;
    3765.                 desc = avcodec_descriptor_get(out_codec->id);
    3766.                 if (desc)
    3767.                     out_codec_name = desc->name;
    3768.                 if (!strcmp(encoder_name, out_codec_name))
    3769.                     encoder_name = "native";
    3770.             }
    3771.  
    3772.             av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
    3773.                    in_codec_name, decoder_name,
    3774.                    out_codec_name, encoder_name);
    3775.         }
    3776.         av_log(NULL, AV_LOG_INFO, "\n");
    3777.     }
    3778.  
    3779.     if (ret) {
    3780.         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
    3781.         return ret;
    3782.     }
    3783.  
    3784.     atomic_store(&transcode_init_done, 1);
    3785.  
    3786.     return 0;
    3787. }
    3788.  
    3789. /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
    3790. static int need_output(void)
    3791. {
    3792.     int i;
    3793.  
    3794.     for (i = 0; i < nb_output_streams; i++) {
    3795.         OutputStream *ost    = output_streams[i];
    3796.         OutputFile *of       = output_files[ost->file_index];
    3797.         AVFormatContext *os  = output_files[ost->file_index]->ctx;
    3798.  
    3799.         if (ost->finished ||
    3800.             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
    3801.             continue;
    3802.         if (ost->frame_number >= ost->max_frames) {
    3803.             int j;
    3804.             for (j = 0; j < of->ctx->nb_streams; j++)
    3805.                 close_output_stream(output_streams[of->ost_index + j]);
    3806.             continue;
    3807.         }
    3808.  
    3809.         return 1;
    3810.     }
    3811.  
    3812.     return 0;
    3813. }
    3814.  
    3815. /**
    3816.  * Select the output stream to process.
    3817.  *
    3818.  * @return  selected output stream, or NULL if none available
    3819.  */
    3820. static OutputStream *choose_output(void)
    3821. {
    3822.     int i;
    3823.     int64_t opts_min = INT64_MAX;
    3824.     OutputStream *ost_min = NULL;
    3825.  
    3826.     for (i = 0; i < nb_output_streams; i++) {
    3827.         OutputStream *ost = output_streams[i];
    3828.         int64_t opts = ost->st->cur_dts == AV_NOPTS_VALUE ? INT64_MIN :
    3829.                        av_rescale_q(ost->st->cur_dts, ost->st->time_base,
    3830.                                     AV_TIME_BASE_Q);
    3831.         if (ost->st->cur_dts == AV_NOPTS_VALUE)
    3832.             av_log(NULL, AV_LOG_DEBUG, "cur_dts is invalid (this is harmless if it occurs once at the start per stream)\n");
    3833.  
    3834.         if (!ost->initialized && !ost->inputs_done)
    3835.             return ost;
    3836.  
    3837.         if (!ost->finished && opts < opts_min) {
    3838.             opts_min = opts;
    3839.             ost_min  = ost->unavailable ? NULL : ost;
    3840.         }
    3841.     }
    3842.     return ost_min;
    3843. }
    3844.  
    3845. static void set_tty_echo(int on)
    3846. {
    3847. #if HAVE_TERMIOS_H
    3848.     struct termios tty;
    3849.     if (tcgetattr(0, &tty) == 0) {
    3850.         if (on) tty.c_lflag |= ECHO;
    3851.         else    tty.c_lflag &= ~ECHO;
    3852.         tcsetattr(0, TCSANOW, &tty);
    3853.     }
    3854. #endif
    3855. }
    3856.  
    3857. static int check_keyboard_interaction(int64_t cur_time)
    3858. {
    3859.     int i, ret, key;
    3860.     static int64_t last_time;
    3861.     if (received_nb_signals)
    3862.         return AVERROR_EXIT;
    3863.     /* read_key() returns 0 on EOF */
    3864.     if(cur_time - last_time >= 100000 && !run_as_daemon){
    3865.         key =  read_key();
    3866.         last_time = cur_time;
    3867.     }else
    3868.         key = -1;
    3869.     if (key == 'q')
    3870.         return AVERROR_EXIT;
    3871.     if (key == '+') av_log_set_level(av_log_get_level()+10);
    3872.     if (key == '-') av_log_set_level(av_log_get_level()-10);
    3873.     if (key == 's') qp_hist     ^= 1;
    3874.     if (key == 'h'){
    3875.         if (do_hex_dump){
    3876.             do_hex_dump = do_pkt_dump = 0;
    3877.         } else if(do_pkt_dump){
    3878.             do_hex_dump = 1;
    3879.         } else
    3880.             do_pkt_dump = 1;
    3881.         av_log_set_level(AV_LOG_DEBUG);
    3882.     }
    3883.     if (key == 'c' || key == 'C'){
    3884.         char buf[4096], target[64], command[256], arg[256] = {0};
    3885.         double time;
    3886.         int k, n = 0;
    3887.         fprintf(stderr, "\nEnter command: |all );
    3888.         i = 0;
    3889.         set_tty_echo(1);
    3890.         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
    3891.             if (k > 0)
    3892.                 buf[i++] = k;
    3893.         buf[i] = 0;
    3894.         set_tty_echo(0);
    3895.         fprintf(stderr, "\n");
    3896.         if (k > 0 &&
    3897.             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
    3898.             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
    3899.                    target, time, command, arg);
    3900.             for (i = 0; i < nb_filtergraphs; i++) {
    3901.                 FilterGraph *fg = filtergraphs[i];
    3902.                 if (fg->graph) {
    3903.                     if (time < 0) {
    3904.                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
    3905.                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
    3906.                         fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", i, ret, buf);
    3907.                     } else if (key == 'c') {
    3908.                         fprintf(stderr, "Queuing commands only on filters supporting the specific command is unsupported\n");
    3909.                         ret = AVERROR_PATCHWELCOME;
    3910.                     } else {
    3911.                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
    3912.                         if (ret < 0)
    3913.                             fprintf(stderr, "Queuing command failed with error %s\n", av_err2str(ret));
    3914.                     }
    3915.                 }
    3916.             }
    3917.         } else {
    3918.             av_log(NULL, AV_LOG_ERROR,
    3919.                    "Parse error, at least 3 arguments were expected, "
    3920.                    "only %d given in string '%s'\n", n, buf);
    3921.         }
    3922.     }
    3923.     if (key == 'd' || key == 'D'){
    3924.         int debug=0;
    3925.         if(key == 'D') {
    3926.             debug = input_streams[0]->st->codec->debug<<1;
    3927.             if(!debug) debug = 1;
    3928.             while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
    3929.                 debug += debug;
    3930.         }else{
    3931.             char buf[32];
    3932.             int k = 0;
    3933.             i = 0;
    3934.             set_tty_echo(1);
    3935.             while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
    3936.                 if (k > 0)
    3937.                     buf[i++] = k;
    3938.             buf[i] = 0;
    3939.             set_tty_echo(0);
    3940.             fprintf(stderr, "\n");
    3941.             if (k <= 0 || sscanf(buf, "%d", &debug)!=1)
    3942.                 fprintf(stderr,"error parsing debug value\n");
    3943.         }
    3944.         for(i=0;i
    3945.             input_streams[i]->st->codec->debug = debug;
    3946.         }
    3947.         for(i=0;i
    3948.             OutputStream *ost = output_streams[i];
    3949.             ost->enc_ctx->debug = debug;
    3950.         }
    3951.         if(debug) av_log_set_level(AV_LOG_DEBUG);
    3952.         fprintf(stderr,"debug=%d\n", debug);
    3953.     }
    3954.     if (key == '?'){
    3955.         fprintf(stderr, "key    function\n"
    3956.                         "?      show this help\n"
    3957.                         "+      increase verbosity\n"
    3958.                         "-      decrease verbosity\n"
    3959.                         "c      Send command to first matching filter supporting it\n"
    3960.                         "C      Send/Queue command to all matching filters\n"
    3961.                         "D      cycle through available debug modes\n"
    3962.                         "h      dump packets/hex press to cycle through the 3 states\n"
    3963.                         "q      quit\n"
    3964.                         "s      Show QP histogram\n"
    3965.         );
    3966.     }
    3967.     return 0;
    3968. }
    3969.  
    3970. #if HAVE_PTHREADS
    3971. static void *input_thread(void *arg)
    3972. {
    3973.     InputFile *f = arg;
    3974.     unsigned flags = f->non_blocking ? AV_THREAD_MESSAGE_NONBLOCK : 0;
    3975.     int ret = 0;
    3976.  
    3977.     while (1) {
    3978.         AVPacket pkt;
    3979.         ret = av_read_frame(f->ctx, &pkt);
    3980.  
    3981.         if (ret == AVERROR(EAGAIN)) {
    3982.             av_usleep(10000);
    3983.             continue;
    3984.         }
    3985.         if (ret < 0) {
    3986.             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
    3987.             break;
    3988.         }
    3989.         ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
    3990.         if (flags && ret == AVERROR(EAGAIN)) {
    3991.             flags = 0;
    3992.             ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
    3993.             av_log(f->ctx, AV_LOG_WARNING,
    3994.                    "Thread message queue blocking; consider raising the "
    3995.                    "thread_queue_size option (current value: %d)\n",
    3996.                    f->thread_queue_size);
    3997.         }
    3998.         if (ret < 0) {
    3999.             if (ret != AVERROR_EOF)
    4000.                 av_log(f->ctx, AV_LOG_ERROR,
    4001.                        "Unable to send packet to main thread: %s\n",
    4002.                        av_err2str(ret));
    4003.             av_packet_unref(&pkt);
    4004.             av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
    4005.             break;
    4006.         }
    4007.     }
    4008.  
    4009.     return NULL;
    4010. }
    4011.  
    4012. static void free_input_threads(void)
    4013. {
    4014.     int i;
    4015.  
    4016.     for (i = 0; i < nb_input_files; i++) {
    4017.         InputFile *f = input_files[i];
    4018.         AVPacket pkt;
    4019.  
    4020.         if (!f || !f->in_thread_queue)
    4021.             continue;
    4022.         av_thread_message_queue_set_err_send(f->in_thread_queue, AVERROR_EOF);
    4023.         while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
    4024.             av_packet_unref(&pkt);
    4025.  
    4026.         pthread_join(f->thread, NULL);
    4027.         f->joined = 1;
    4028.         av_thread_message_queue_free(&f->in_thread_queue);
    4029.     }
    4030. }
    4031.  
    4032. static int init_input_threads(void)
    4033. {
    4034.     int i, ret;
    4035.  
    4036.     if (nb_input_files == 1)
    4037.         return 0;
    4038.  
    4039.     for (i = 0; i < nb_input_files; i++) {
    4040.         InputFile *f = input_files[i];
    4041.  
    4042.         if (f->ctx->pb ? !f->ctx->pb->seekable :
    4043.             strcmp(f->ctx->iformat->name, "lavfi"))
    4044.             f->non_blocking = 1;
    4045.         ret = av_thread_message_queue_alloc(&f->in_thread_queue,
    4046.                                             f->thread_queue_size, sizeof(AVPacket));
    4047.         if (ret < 0)
    4048.             return ret;
    4049.  
    4050.         if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
    4051.             av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
    4052.             av_thread_message_queue_free(&f->in_thread_queue);
    4053.             return AVERROR(ret);
    4054.         }
    4055.     }
    4056.     return 0;
    4057. }
    4058.  
    4059. static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
    4060. {
    4061.     return av_thread_message_queue_recv(f->in_thread_queue, pkt,
    4062.                                         f->non_blocking ?
    4063.                                         AV_THREAD_MESSAGE_NONBLOCK : 0);
    4064. }
    4065. #endif
    4066.  
    4067. static int get_input_packet(InputFile *f, AVPacket *pkt)
    4068. {
    4069.     if (f->rate_emu) {
    4070.         int i;
    4071.         for (i = 0; i < f->nb_streams; i++) {
    4072.             InputStream *ist = input_streams[f->ist_index + i];
    4073.             int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
    4074.             int64_t now = av_gettime_relative() - ist->start;
    4075.             if (pts > now)
    4076.                 return AVERROR(EAGAIN);
    4077.         }
    4078.     }
    4079.  
    4080. #if HAVE_PTHREADS
    4081.     if (nb_input_files > 1)
    4082.         return get_input_packet_mt(f, pkt);
    4083. #endif
    4084.     return av_read_frame(f->ctx, pkt);
    4085. }
    4086.  
    4087. static int got_eagain(void)
    4088. {
    4089.     int i;
    4090.     for (i = 0; i < nb_output_streams; i++)
    4091.         if (output_streams[i]->unavailable)
    4092.             return 1;
    4093.     return 0;
    4094. }
    4095.  
    4096. static void reset_eagain(void)
    4097. {
    4098.     int i;
    4099.     for (i = 0; i < nb_input_files; i++)
    4100.         input_files[i]->eagain = 0;
    4101.     for (i = 0; i < nb_output_streams; i++)
    4102.         output_streams[i]->unavailable = 0;
    4103. }
    4104.  
    4105. // set duration to max(tmp, duration) in a proper time base and return duration's time_base
    4106. static AVRational duration_max(int64_t tmp, int64_t *duration, AVRational tmp_time_base,
    4107.                                 AVRational time_base)
    4108. {
    4109.     int ret;
    4110.  
    4111.     if (!*duration) {
    4112.         *duration = tmp;
    4113.         return tmp_time_base;
    4114.     }
    4115.  
    4116.     ret = av_compare_ts(*duration, time_base, tmp, tmp_time_base);
    4117.     if (ret < 0) {
    4118.         *duration = tmp;
    4119.         return tmp_time_base;
    4120.     }
    4121.  
    4122.     return time_base;
    4123. }
    4124.  
    4125. static int seek_to_start(InputFile *ifile, AVFormatContext *is)
    4126. {
    4127.     InputStream *ist;
    4128.     AVCodecContext *avctx;
    4129.     int i, ret, has_audio = 0;
    4130.     int64_t duration = 0;
    4131.  
    4132.     ret = av_seek_frame(is, -1, is->start_time, 0);
    4133.     if (ret < 0)
    4134.         return ret;
    4135.  
    4136.     for (i = 0; i < ifile->nb_streams; i++) {
    4137.         ist   = input_streams[ifile->ist_index + i];
    4138.         avctx = ist->dec_ctx;
    4139.  
    4140.         // flush decoders
    4141.         if (ist->decoding_needed) {
    4142.             process_input_packet(ist, NULL, 1);
    4143.             avcodec_flush_buffers(avctx);
    4144.         }
    4145.  
    4146.         /* duration is the length of the last frame in a stream
    4147.          * when audio stream is present we don't care about
    4148.          * last video frame length because it's not defined exactly */
    4149.         if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples)
    4150.             has_audio = 1;
    4151.     }
    4152.  
    4153.     for (i = 0; i < ifile->nb_streams; i++) {
    4154.         ist   = input_streams[ifile->ist_index + i];
    4155.         avctx = ist->dec_ctx;
    4156.  
    4157.         if (has_audio) {
    4158.             if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples) {
    4159.                 AVRational sample_rate = {1, avctx->sample_rate};
    4160.  
    4161.                 duration = av_rescale_q(ist->nb_samples, sample_rate, ist->st->time_base);
    4162.             } else
    4163.                 continue;
    4164.         } else {
    4165.             if (ist->framerate.num) {
    4166.                 duration = av_rescale_q(1, ist->framerate, ist->st->time_base);
    4167.             } else if (ist->st->avg_frame_rate.num) {
    4168.                 duration = av_rescale_q(1, ist->st->avg_frame_rate, ist->st->time_base);
    4169.             } else duration = 1;
    4170.         }
    4171.         if (!ifile->duration)
    4172.             ifile->time_base = ist->st->time_base;
    4173.         /* the total duration of the stream, max_pts - min_pts is
    4174.          * the duration of the stream without the last frame */
    4175.         duration += ist->max_pts - ist->min_pts;
    4176.         ifile->time_base = duration_max(duration, &ifile->duration, ist->st->time_base,
    4177.                                         ifile->time_base);
    4178.     }
    4179.  
    4180.     if (ifile->loop > 0)
    4181.         ifile->loop--;
    4182.  
    4183.     return ret;
    4184. }
    4185.  
    4186. /*
    4187.  * Return
    4188.  * - 0 -- one packet was read and processed
    4189.  * - AVERROR(EAGAIN) -- no packets were available for selected file,
    4190.  *   this function should be called again
    4191.  * - AVERROR_EOF -- this function should not be called again
    4192.  */
    4193. static int process_input(int file_index)
    4194. {
    4195.     InputFile *ifile = input_files[file_index];
    4196.     AVFormatContext *is;
    4197.     InputStream *ist;
    4198.     AVPacket pkt;
    4199.     int ret, i, j;
    4200.     int64_t duration;
    4201.     int64_t pkt_dts;
    4202.  
    4203.     is  = ifile->ctx;
    4204.     ret = get_input_packet(ifile, &pkt);
    4205.  
    4206.     if (ret == AVERROR(EAGAIN)) {
    4207.         ifile->eagain = 1;
    4208.         return ret;
    4209.     }
    4210.     if (ret < 0 && ifile->loop) {
    4211.         if ((ret = seek_to_start(ifile, is)) < 0)
    4212.             return ret;
    4213.         ret = get_input_packet(ifile, &pkt);
    4214.         if (ret == AVERROR(EAGAIN)) {
    4215.             ifile->eagain = 1;
    4216.             return ret;
    4217.         }
    4218.     }
    4219.     if (ret < 0) {
    4220.         if (ret != AVERROR_EOF) {
    4221.             print_error(is->filename, ret);
    4222.             if (exit_on_error)
    4223.                 exit_program(1);
    4224.         }
    4225.  
    4226.         for (i = 0; i < ifile->nb_streams; i++) {
    4227.             ist = input_streams[ifile->ist_index + i];
    4228.             if (ist->decoding_needed) {
    4229.                 ret = process_input_packet(ist, NULL, 0);
    4230.                 if (ret>0)
    4231.                     return 0;
    4232.             }
    4233.  
    4234.             /* mark all outputs that don't go through lavfi as finished */
    4235.             for (j = 0; j < nb_output_streams; j++) {
    4236.                 OutputStream *ost = output_streams[j];
    4237.  
    4238.                 if (ost->source_index == ifile->ist_index + i &&
    4239.                     (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
    4240.                     finish_output_stream(ost);
    4241.             }
    4242.         }
    4243.  
    4244.         ifile->eof_reached = 1;
    4245.         return AVERROR(EAGAIN);
    4246.     }
    4247.  
    4248.     reset_eagain();
    4249.  
    4250.     if (do_pkt_dump) {
    4251.         av_pkt_dump_log2(NULL, AV_LOG_INFO, &pkt, do_hex_dump,
    4252.                          is->streams[pkt.stream_index]);
    4253.     }
    4254.     /* the following test is needed in case new streams appear
    4255.        dynamically in stream : we ignore them */
    4256.     if (pkt.stream_index >= ifile->nb_streams) {
    4257.         report_new_stream(file_index, &pkt);
    4258.         goto discard_packet;
    4259.     }
    4260.  
    4261.     ist = input_streams[ifile->ist_index + pkt.stream_index];
    4262.  
    4263.     ist->data_size += pkt.size;
    4264.     ist->nb_packets++;
    4265.  
    4266.     if (ist->discard)
    4267.         goto discard_packet;
    4268.  
    4269.     if (exit_on_error && (pkt.flags & AV_PKT_FLAG_CORRUPT)) {
    4270.         av_log(NULL, AV_LOG_FATAL, "%s: corrupt input packet in stream %d\n", is->filename, pkt.stream_index);
    4271.         exit_program(1);
    4272.     }
    4273.  
    4274.     if (debug_ts) {
    4275.         av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
    4276.                "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
    4277.                ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
    4278.                av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
    4279.                av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
    4280.                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
    4281.                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
    4282.                av_ts2str(input_files[ist->file_index]->ts_offset),
    4283.                av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
    4284.     }
    4285.  
    4286.     if(!ist->wrap_correction_done && is->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
    4287.         int64_t stime, stime2;
    4288.         // Correcting starttime based on the enabled streams
    4289.         // FIXME this ideally should be done before the first use of starttime but we do not know which are the enabled streams at that point.
    4290.         //       so we instead do it here as part of discontinuity handling
    4291.         if (   ist->next_dts == AV_NOPTS_VALUE
    4292.             && ifile->ts_offset == -is->start_time
    4293.             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
    4294.             int64_t new_start_time = INT64_MAX;
    4295.             for (i=0; inb_streams; i++) {
    4296.                 AVStream *st = is->streams[i];
    4297.                 if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
    4298.                     continue;
    4299.                 new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
    4300.             }
    4301.             if (new_start_time > is->start_time) {
    4302.                 av_log(is, AV_LOG_VERBOSE, "Correcting start time by %"PRId64"\n", new_start_time - is->start_time);
    4303.                 ifile->ts_offset = -new_start_time;
    4304.             }
    4305.         }
    4306.  
    4307.         stime = av_rescale_q(is->start_time, AV_TIME_BASE_Q, ist->st->time_base);
    4308.         stime2= stime + (1ULL<st->pts_wrap_bits);
    4309.         ist->wrap_correction_done = 1;
    4310.  
    4311.         if(stime2 > stime && pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
    4312.             pkt.dts -= 1ULL<st->pts_wrap_bits;
    4313.             ist->wrap_correction_done = 0;
    4314.         }
    4315.         if(stime2 > stime && pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
    4316.             pkt.pts -= 1ULL<st->pts_wrap_bits;
    4317.             ist->wrap_correction_done = 0;
    4318.         }
    4319.     }
    4320.  
    4321.     /* add the stream-global side data to the first packet */
    4322.     if (ist->nb_packets == 1) {
    4323.         for (i = 0; i < ist->st->nb_side_data; i++) {
    4324.             AVPacketSideData *src_sd = &ist->st->side_data[i];
    4325.             uint8_t *dst_data;
    4326.  
    4327.             if (src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
    4328.                 continue;
    4329.  
    4330.             if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
    4331.                 continue;
    4332.  
    4333.             dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
    4334.             if (!dst_data)
    4335.                 exit_program(1);
    4336.  
    4337.             memcpy(dst_data, src_sd->data, src_sd->size);
    4338.         }
    4339.     }
    4340.  
    4341.     if (pkt.dts != AV_NOPTS_VALUE)
    4342.         pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
    4343.     if (pkt.pts != AV_NOPTS_VALUE)
    4344.         pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
    4345.  
    4346.     if (pkt.pts != AV_NOPTS_VALUE)
    4347.         pkt.pts *= ist->ts_scale;
    4348.     if (pkt.dts != AV_NOPTS_VALUE)
    4349.         pkt.dts *= ist->ts_scale;
    4350.  
    4351.     pkt_dts = av_rescale_q_rnd(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
    4352.     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
    4353.          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
    4354.         pkt_dts != AV_NOPTS_VALUE && ist->next_dts == AV_NOPTS_VALUE && !copy_ts
    4355.         && (is->iformat->flags & AVFMT_TS_DISCONT) && ifile->last_ts != AV_NOPTS_VALUE) {
    4356.         int64_t delta   = pkt_dts - ifile->last_ts;
    4357.         if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
    4358.             delta >  1LL*dts_delta_threshold*AV_TIME_BASE){
    4359.             ifile->ts_offset -= delta;
    4360.             av_log(NULL, AV_LOG_DEBUG,
    4361.                    "Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
    4362.                    delta, ifile->ts_offset);
    4363.             pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
    4364.             if (pkt.pts != AV_NOPTS_VALUE)
    4365.                 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
    4366.         }
    4367.     }
    4368.  
    4369.     duration = av_rescale_q(ifile->duration, ifile->time_base, ist->st->time_base);
    4370.     if (pkt.pts != AV_NOPTS_VALUE) {
    4371.         pkt.pts += duration;
    4372.         ist->max_pts = FFMAX(pkt.pts, ist->max_pts);
    4373.         ist->min_pts = FFMIN(pkt.pts, ist->min_pts);
    4374.     }
    4375.  
    4376.     if (pkt.dts != AV_NOPTS_VALUE)
    4377.         pkt.dts += duration;
    4378.  
    4379.     pkt_dts = av_rescale_q_rnd(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
    4380.     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
    4381.          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
    4382.          pkt_dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
    4383.         !copy_ts) {
    4384.         int64_t delta   = pkt_dts - ist->next_dts;
    4385.         if (is->iformat->flags & AVFMT_TS_DISCONT) {
    4386.             if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
    4387.                 delta >  1LL*dts_delta_threshold*AV_TIME_BASE ||
    4388.                 pkt_dts + AV_TIME_BASE/10 < FFMAX(ist->pts, ist->dts)) {
    4389.                 ifile->ts_offset -= delta;
    4390.                 av_log(NULL, AV_LOG_DEBUG,
    4391.                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
    4392.                        delta, ifile->ts_offset);
    4393.                 pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
    4394.                 if (pkt.pts != AV_NOPTS_VALUE)
    4395.                     pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
    4396.             }
    4397.         } else {
    4398.             if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
    4399.                  delta >  1LL*dts_error_threshold*AV_TIME_BASE) {
    4400.                 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
    4401.                 pkt.dts = AV_NOPTS_VALUE;
    4402.             }
    4403.             if (pkt.pts != AV_NOPTS_VALUE){
    4404.                 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
    4405.                 delta   = pkt_pts - ist->next_dts;
    4406.                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
    4407.                      delta >  1LL*dts_error_threshold*AV_TIME_BASE) {
    4408.                     av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
    4409.                     pkt.pts = AV_NOPTS_VALUE;
    4410.                 }
    4411.             }
    4412.         }
    4413.     }
    4414.  
    4415.     if (pkt.dts != AV_NOPTS_VALUE)
    4416.         ifile->last_ts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
    4417.  
    4418.     if (debug_ts) {
    4419.         av_log(NULL, AV_LOG_INFO, "demuxer+ffmpeg -> ist_index:%d type:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
    4420.                ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
    4421.                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
    4422.                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
    4423.                av_ts2str(input_files[ist->file_index]->ts_offset),
    4424.                av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
    4425.     }
    4426.  
    4427.     sub2video_heartbeat(ist, pkt.pts);
    4428.  
    4429.     process_input_packet(ist, &pkt, 0);
    4430.  
    4431. discard_packet:
    4432.     av_packet_unref(&pkt);
    4433.  
    4434.     return 0;
    4435. }
    4436.  
    4437. /**
    4438.  * Perform a step of transcoding for the specified filter graph.
    4439.  *
    4440.  * @param[in]  graph     filter graph to consider
    4441.  * @param[out] best_ist  input stream where a frame would allow to continue
    4442.  * @return  0 for success, <0 for error
    4443.  */
    4444. static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
    4445. {
    4446.     int i, ret;
    4447.     int nb_requests, nb_requests_max = 0;
    4448.     InputFilter *ifilter;
    4449.     InputStream *ist;
    4450.  
    4451.     *best_ist = NULL;
    4452.     ret = avfilter_graph_request_oldest(graph->graph);
    4453.     if (ret >= 0)
    4454.         return reap_filters(0);
    4455.  
    4456.     if (ret == AVERROR_EOF) {
    4457.         ret = reap_filters(1);
    4458.         for (i = 0; i < graph->nb_outputs; i++)
    4459.             close_output_stream(graph->outputs[i]->ost);
    4460.         return ret;
    4461.     }
    4462.     if (ret != AVERROR(EAGAIN))
    4463.         return ret;
    4464.  
    4465.     for (i = 0; i < graph->nb_inputs; i++) {
    4466.         ifilter = graph->inputs[i];
    4467.         ist = ifilter->ist;
    4468.         if (input_files[ist->file_index]->eagain ||
    4469.             input_files[ist->file_index]->eof_reached)
    4470.             continue;
    4471.         nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter);
    4472.         if (nb_requests > nb_requests_max) {
    4473.             nb_requests_max = nb_requests;
    4474.             *best_ist = ist;
    4475.         }
    4476.     }
    4477.  
    4478.     if (!*best_ist)
    4479.         for (i = 0; i < graph->nb_outputs; i++)
    4480.             graph->outputs[i]->ost->unavailable = 1;
    4481.  
    4482.     return 0;
    4483. }
    4484.  
    4485. /**
    4486.  * Run a single step of transcoding.
    4487.  *
    4488.  * @return  0 for success, <0 for error
    4489.  */
    4490. static int transcode_step(void)
    4491. {
    4492.     OutputStream *ost;
    4493.     InputStream  *ist = NULL;
    4494.     int ret;
    4495.  
    4496.     ost = choose_output();
    4497.     if (!ost) {
    4498.         if (got_eagain()) {
    4499.             reset_eagain();
    4500.             av_usleep(10000);
    4501.             return 0;
    4502.         }
    4503.         av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
    4504.         return AVERROR_EOF;
    4505.     }
    4506.  
    4507.     if (ost->filter && !ost->filter->graph->graph) {
    4508.         if (ifilter_has_all_input_formats(ost->filter->graph)) {
    4509.             ret = configure_filtergraph(ost->filter->graph);
    4510.             if (ret < 0) {
    4511.                 av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
    4512.                 return ret;
    4513.             }
    4514.         }
    4515.     }
    4516.  
    4517.     if (ost->filter && ost->filter->graph->graph) {
    4518.         if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
    4519.             return ret;
    4520.         if (!ist)
    4521.             return 0;
    4522.     } else if (ost->filter) {
    4523.         int i;
    4524.         for (i = 0; i < ost->filter->graph->nb_inputs; i++) {
    4525.             InputFilter *ifilter = ost->filter->graph->inputs[i];
    4526.             if (!ifilter->ist->got_output && !input_files[ifilter->ist->file_index]->eof_reached) {
    4527.                 ist = ifilter->ist;
    4528.                 break;
    4529.             }
    4530.         }
    4531.         if (!ist) {
    4532.             ost->inputs_done = 1;
    4533.             return 0;
    4534.         }
    4535.     } else {
    4536.         av_assert0(ost->source_index >= 0);
    4537.         ist = input_streams[ost->source_index];
    4538.     }
    4539.  
    4540.     ret = process_input(ist->file_index);
    4541.     if (ret == AVERROR(EAGAIN)) {
    4542.         if (input_files[ist->file_index]->eagain)
    4543.             ost->unavailable = 1;
    4544.         return 0;
    4545.     }
    4546.  
    4547.     if (ret < 0)
    4548.         return ret == AVERROR_EOF ? 0 : ret;
    4549.  
    4550.     return reap_filters(0);
    4551. }
    4552.  
    4553. /*
    4554.  * The following code is the main loop of the file converter
    4555.  */
    4556. static int transcode(void(call_back)(int current,int total))
    4557. {
    4558.     int ret, i;
    4559.     AVFormatContext *os;
    4560.     OutputStream *ost;
    4561.     InputStream *ist;
    4562.     int64_t timer_start;
    4563.     int64_t total_packets_written = 0;
    4564.  
    4565.     ret = transcode_init();
    4566.     if (ret < 0)
    4567.         goto fail;
    4568.  
    4569.     if (stdin_interaction) {
    4570.         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
    4571.     }
    4572.  
    4573.     timer_start = av_gettime_relative();
    4574.  
    4575. #if HAVE_PTHREADS
    4576.     if ((ret = init_input_threads()) < 0)
    4577.         goto fail;
    4578. #endif
    4579.  
    4580.     while (!received_sigterm) {
    4581.         int64_t cur_time= av_gettime_relative();
    4582.  
    4583.         /* if 'q' pressed, exits */
    4584.         if (stdin_interaction)
    4585.             if (check_keyboard_interaction(cur_time) < 0)
    4586.                 break;
    4587.  
    4588.         /* check if there's any stream where output is still needed */
    4589.         if (!need_output()) {
    4590.             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
    4591.             break;
    4592.         }
    4593.  
    4594.         ret = transcode_step();
    4595.         if (ret < 0 && ret != AVERROR_EOF) {
    4596.             char errbuf[128];
    4597.             av_strerror(ret, errbuf, sizeof(errbuf));
    4598.  
    4599.             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
    4600.             break;
    4601.         }
    4602.  
    4603.         /* dump report by using the output first video and audio streams */
    4604.         print_report(0, timer_start, cur_time,call_back);
    4605.     }
    4606. #if HAVE_PTHREADS
    4607.     free_input_threads();
    4608. #endif
    4609.  
    4610.     /* at the end of stream, we must flush the decoder buffers */
    4611.     for (i = 0; i < nb_input_streams; i++) {
    4612.         ist = input_streams[i];
    4613.         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
    4614.             process_input_packet(ist, NULL, 0);
    4615.         }
    4616.     }
    4617.     flush_encoders();
    4618.  
    4619.     term_exit();
    4620.  
    4621.     /* write the trailer if needed and close file */
    4622.     for (i = 0; i < nb_output_files; i++) {
    4623.         os = output_files[i]->ctx;
    4624.         if (!output_files[i]->header_written) {
    4625.             av_log(NULL, AV_LOG_ERROR,
    4626.                    "Nothing was written into output file %d (%s), because "
    4627.                    "at least one of its streams received no packets.\n",
    4628.                    i, os->filename);
    4629.             continue;
    4630.         }
    4631.         if ((ret = av_write_trailer(os)) < 0) {
    4632.             av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s\n", os->filename, av_err2str(ret));
    4633.             if (exit_on_error)
    4634.                 exit_program(1);
    4635.         }
    4636.     }
    4637.  
    4638.     /* dump report by using the first video and audio streams */
    4639.     print_report(1, timer_start, av_gettime_relative(),call_back);
    4640.  
    4641.     /* close each encoder */
    4642.     for (i = 0; i < nb_output_streams; i++) {
    4643.         ost = output_streams[i];
    4644.         if (ost->encoding_needed) {
    4645.             av_freep(&ost->enc_ctx->stats_in);
    4646.         }
    4647.         total_packets_written += ost->packets_written;
    4648.     }
    4649.  
    4650.     if (!total_packets_written && (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT)) {
    4651.         av_log(NULL, AV_LOG_FATAL, "Empty output\n");
    4652.         exit_program(1);
    4653.     }
    4654.  
    4655.     /* close each decoder */
    4656.     for (i = 0; i < nb_input_streams; i++) {
    4657.         ist = input_streams[i];
    4658.         if (ist->decoding_needed) {
    4659.             avcodec_close(ist->dec_ctx);
    4660.             if (ist->hwaccel_uninit)
    4661.                 ist->hwaccel_uninit(ist->dec_ctx);
    4662.         }
    4663.     }
    4664.  
    4665.     av_buffer_unref(&hw_device_ctx);
    4666.  
    4667.     /* finished ! */
    4668.     ret = 0;
    4669.  
    4670.  fail:
    4671. #if HAVE_PTHREADS
    4672.     free_input_threads();
    4673. #endif
    4674.  
    4675.     if (output_streams) {
    4676.         for (i = 0; i < nb_output_streams; i++) {
    4677.             ost = output_streams[i];
    4678.             if (ost) {
    4679.                 if (ost->logfile) {
    4680.                     if (fclose(ost->logfile))
    4681.                         av_log(NULL, AV_LOG_ERROR,
    4682.                                "Error closing logfile, loss of information possible: %s\n",
    4683.                                av_err2str(AVERROR(errno)));
    4684.                     ost->logfile = NULL;
    4685.                 }
    4686.                 av_freep(&ost->forced_kf_pts);
    4687.                 av_freep(&ost->apad);
    4688.                 av_freep(&ost->disposition);
    4689.                 av_dict_free(&ost->encoder_opts);
    4690.                 av_dict_free(&ost->sws_dict);
    4691.                 av_dict_free(&ost->swr_opts);
    4692.                 av_dict_free(&ost->resample_opts);
    4693.             }
    4694.         }
    4695.     }
    4696.     return ret;
    4697. }
    4698.  
    4699.  
    4700. static int64_t getutime(void)
    4701. {
    4702. #if HAVE_GETRUSAGE
    4703.     struct rusage rusage;
    4704.  
    4705.     getrusage(RUSAGE_SELF, &rusage);
    4706.     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
    4707. #elif HAVE_GETPROCESSTIMES
    4708.     HANDLE proc;
    4709.     FILETIME c, e, k, u;
    4710.     proc = GetCurrentProcess();
    4711.     GetProcessTimes(proc, &c, &e, &k, &u);
    4712.     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
    4713. #else
    4714.     return av_gettime_relative();
    4715. #endif
    4716. }
    4717.  
    4718. static int64_t getmaxrss(void)
    4719. {
    4720. #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
    4721.     struct rusage rusage;
    4722.     getrusage(RUSAGE_SELF, &rusage);
    4723.     return (int64_t)rusage.ru_maxrss * 1024;
    4724. #elif HAVE_GETPROCESSMEMORYINFO
    4725.     HANDLE proc;
    4726.     PROCESS_MEMORY_COUNTERS memcounters;
    4727.     proc = GetCurrentProcess();
    4728.     memcounters.cb = sizeof(memcounters);
    4729.     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
    4730.     return memcounters.PeakPagefileUsage;
    4731. #else
    4732.     return 0;
    4733. #endif
    4734. }
    4735.  
    4736. static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
    4737. {
    4738. }
    4739. //命令函数的入口
    4740. int run_ffmpeg_command(int argc, char **argv,void(call_back)(int current,int total))
    4741. {
    4742.     int i, ret;
    4743.     int64_t ti;
    4744.  
    4745.     init_dynload();
    4746.  
    4747.     register_exit(ffmpeg_cleanup);
    4748.  
    4749.     setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
    4750.  
    4751.     av_log_set_flags(AV_LOG_SKIP_REPEATED);
    4752.     parse_loglevel(argc, argv, options);
    4753.  
    4754.     if(argc>1 && !strcmp(argv[1], "-d")){
    4755.         run_as_daemon=1;
    4756.         av_log_set_callback(log_callback_null);
    4757.         argc--;
    4758.         argv++;
    4759.     }
    4760.  
    4761.     avcodec_register_all();
    4762. #if CONFIG_AVDEVICE
    4763.     avdevice_register_all();
    4764. #endif
    4765.     avfilter_register_all();
    4766.     av_register_all();
    4767.     avformat_network_init();
    4768.  
    4769.     show_banner(argc, argv, options);
    4770.  
    4771.     /* parse options and open all input/output files */
    4772.     ret = ffmpeg_parse_options(argc, argv);
    4773.     if (ret < 0)
    4774.         exit_program(1);
    4775.  
    4776.     if (nb_output_files <= 0 && nb_input_files == 0) {
    4777.         show_usage();
    4778.         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
    4779.         exit_program(1);
    4780.     }
    4781.  
    4782.     /* file converter / grab */
    4783.     if (nb_output_files <= 0) {
    4784.         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
    4785.         exit_program(1);
    4786.     }
    4787.  
    4788. //     if (nb_input_files == 0) {
    4789. //         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
    4790. //         exit_program(1);
    4791. //     }
    4792.  
    4793.     for (i = 0; i < nb_output_files; i++) {
    4794.         if (strcmp(output_files[i]->ctx->oformat->name, "rtp"))
    4795.             want_sdp = 0;
    4796.     }
    4797.  
    4798.     current_time = ti = getutime();
    4799.     if (transcode(call_back) < 0)
    4800.         exit_program(1);
    4801.     ti = getutime() - ti;
    4802.     if (do_benchmark) {
    4803.         av_log(NULL, AV_LOG_INFO, "bench: utime=%0.3fs\n", ti / 1000000.0);
    4804.     }
    4805.     av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" frames successfully decoded, %"PRIu64" decoding errors\n",
    4806.            decode_error_stat[0], decode_error_stat[1]);
    4807.     if ((decode_error_stat[0] + decode_error_stat[1]) * max_error_rate < decode_error_stat[1])
    4808.         exit_program(69);
    4809.     //注释掉此行代码 如果不注释掉该行代码，命令执行完会导致app退出
    4810.     //exit_program(received_nb_signals ? 255 : main_return_code);
    4811.     //添加如下代码如果不添加再次执行run_ffmpeg_command 直接崩溃 因为没有赋初始值
    4812.     nb_filtergraphs = 0;
    4813.     nb_input_streams = 0;
    4814.     nb_input_files = 0;
    4815.     progress_avio = NULL;
    4816.  
    4817.  
    4818.     input_streams = NULL;
    4819.     nb_input_streams = 0;
    4820.     input_files = NULL;
    4821.     nb_input_files = 0;
    4822.  
    4823.     output_streams = NULL;
    4824.     nb_output_streams = 0;
    4825.     output_files = NULL;
    4826.     nb_output_files = 0;
    4827.     return main_return_code;
    4828. }

    修改native-lib.cpp内容

     

     native-lib.cpp内容如下：

    1. #include 
    2. #include 
    3. #include 
    4. #define TAG "JNI_TAG"
    5. #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,TAG,__VA_ARGS__);
    6. extern "C" {
    7. #include "libavutil/avutil.h"
    8.     //声明方法 argc命令的个数  argv 二维数组
    9. int run_ffmpeg_command(int argc, char **argv,void(call_back)(int current,int total));
    10. //回调函数
    11. static jobject  call_back_jobj;//call_back_jobj 对应于VideoCompress类中的CompressCallback
    12. static JNIEnv *myEnv;
    13. void call_back(int current,int total){
    14.     //LOGE("压缩进度：%d/%d",current,total);
    15.     //把进度回调出去，对象是jobject callback
    16.     if(myEnv!=NULL&&call_back_jobj!=NULL){
    17.         //获取j_mid是会被多次执行
    18.         jclass j_clazz=myEnv->GetObjectClass(call_back_jobj);
    19.         //方法 onCompress对象的方法名 对应VideoCompress类中的CompressCallback接口的onCompress方法
    20.         //(II)V(方法签名 利用javap命令也能打印) --(public void onCompress(int current,int total);onCompress的两个参数都为int类型 onCompress方法的返回值为void)
    21.         jmethodID j_mid=myEnv->GetMethodID(j_clazz,"onCompress","(II)V");
    22.         //调用对象的方法 如果写CallObjectMethod报错，因为知道是无返回值的方法，所以改成CallVoidMethod
    23.         myEnv->CallVoidMethod(call_back_jobj,j_mid,current,total);
    24.     }
    25.  
    26. }
    27. }
    28. extern "C" JNIEXPORT jstring JNICALL
    29. Java_com_suoer_ndk_ffmpegtestapplication_MainActivity_stringFromJNI(
    30.         JNIEnv* env,
    31.         jobject /* this */) {
    32.     //std::string hello = "Hello from C++";
    33.     return env->NewStringUTF(av_version_info());
    34. }extern "C"
    35. JNIEXPORT void JNICALL
    36. Java_com_suoer_ndk_ffmpegtestapplication_VideoCompress_compressVideo(JNIEnv *env, jobject thiz,
    37.                                                                      jobjectArray compress_command,
    38.                                                                      jobject callback) {
    39.     myEnv=env;
    40.     call_back_jobj=env->NewGlobalRef(callback);
    41.     //ffmpeg 处理视频压缩
    42.     //arm这个里面的so都是用来处理音视频的，include都是头文件
    43.     //还有几个没有被打包编译成so,因为这些不算是音视频的处理代码，只是我们现在支持命令(封装)
    44.     //1.获取命令个数
    45.     int argc=env->GetArrayLength(compress_command);
    46.     //2.给char **argv填充数据
    47.     char **argv=(char **)malloc(sizeof(char*)*argc);
    48.     for (int i = 0; i 
    49.         jstring  j_param=(jstring)env->GetObjectArrayElement(compress_command,i);
    50.         argv[i]= (char *)(env->GetStringUTFChars(j_param, NULL));
    51.         LOGE("参数：%s",argv[i]);
    52.     }
    53.     //3.调用命令函数去压缩
    54.      run_ffmpeg_command(argc,argv,call_back);
    55.     //4.释放内存
    56.     for (int i = 0; i 
    57.         free(argv[i]);
    58.     }
    59.     free(argv);
    60.     env->DeleteGlobalRef(call_back_jobj);
    61. }

    5.MainActivity界面优化处理

    首先需要把assets目录中的test.mp4放置手机中

     

     修改MainActivity内容：

    压缩之前首先判断压缩后的文件out.mp4是否存在，如果已经存在，则删除此文件。如果压缩文件已经存在再次压缩会导致崩溃。

     

     

    压缩过程中展示进度条，压缩过程中不允许再次点击压缩按钮

     

    进度弹窗背景： bg_4radius.xml

    1. "1.0" encoding="utf-8"?>
    2. <selector xmlns:android="http://schemas.android.com/apk/res/android">
    3.     <item>
    4.         <shape android:shape="rectangle">
    5.             <solid android:color="@color/white" />
    6.             <corners  android:topLeftRadius="4dp" android:topRightRadius="4dp" android:bottomLeftRadius="4dp" android:bottomRightRadius="4dp"/>
    7.         shape>
    8.     item>
    9. selector>

    进度条进度背景：compress_progressbar.xml

    1. "1.0" encoding="utf-8"?>
    2. <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    3.     <item android:id="@android:id/background">
    4.         
    5.         <shape>
    6.             
    7.             <corners android:radius="6dp" />
    8.             <solid android:color="#ffeeeeee">solid>
    9.         shape>
    10.     item>
    11.  
    12.     <item android:id="@android:id/secondaryProgress">
    13.         <clip>
    14.             <shape>
    15.                 <corners android:radius="6dp" />
    16.                 <gradient
    17.                     android:type="linear"
    18.                     android:useLevel="true"
    19.                     android:angle="270"
    20.                     android:endColor="@color/purple_500"
    21.                     android:startColor="@color/purple_200" />
    22.             shape>
    23.         clip>
    24.     item>
    25.  
    26.     <item android:id="@android:id/progress">
    27.         <clip>
    28.             <shape>
    29.                 <corners android:radius="6dp" />
    30.                 <gradient
    31.                     android:type="linear"
    32.                     android:useLevel="true"
    33.                     android:angle="270"
    34.                     android:endColor="@color/purple_500"
    35.                     android:startColor="@color/purple_200" />
    36.             shape>
    37.         clip>
    38.     item>
    39. layer-list>

    进度弹窗布局文件dialog_progress.xml

    1. "1.0" encoding="utf-8"?>
    2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    3.     android:layout_width="wrap_content"
    4.     android:layout_height="320dp"
    5.     android:layout_gravity="center"
    6.     android:background="@drawable/bg_4radius">
    7.  
    8.     <RelativeLayout
    9.         android:layout_width="match_parent"
    10.         android:layout_height="match_parent"
    11.         >
    12.  
    13.         <LinearLayout
    14.             android:layout_centerInParent="true"
    15.             android:layout_width="match_parent"
    16.             android:layout_height="wrap_content"
    17.             android:gravity="center_horizontal"
    18.             android:orientation="vertical">
    19.  
    20.             <TextView
    21.                 android:id="@+id/tv_dialog_compress_progress"
    22.                 android:layout_width="wrap_content"
    23.                 android:layout_height="wrap_content"
    24.                 android:textColor="@color/purple_500"
    25.                 android:textSize="24sp" />
    26.             <ProgressBar
    27.                 android:id="@+id/compress_progressbar"
    28.                 android:layout_marginLeft="40dp"
    29.                 android:layout_marginRight="40dp"
    30.                 style="?android:attr/progressBarStyleHorizontal"
    31.                 android:layout_width="match_parent"
    32.                 android:max="100"
    33.                 android:min="0"
    34.                 android:progressDrawable="@drawable/compress_progressbar"
    35.                 android:layout_height="12dp" />
    36.             <TextView
    37.                 android:layout_marginBottom="20dp"
    38.                 android:text="视频正在压缩，请稍等…"
    39.                 android:layout_marginTop="40dp"
    40.                 android:textSize="14sp"
    41.                 android:textColor="#CCCCCC"
    42.                 android:layout_width="wrap_content"
    43.                 android:layout_height="wrap_content" />
    44.  
    45.         LinearLayout>
    46.  
    47.  
    48.  
    49.     RelativeLayout>
    50.  
    51. RelativeLayout>

    弹窗样式styles.xml

    1. "1.0" encoding="utf-8"?>
    2. <resources>
    3.     <style name="normal_dialog" parent="android:Theme.Dialog">
    4.         <item name="android:background">@android:color/transparentitem>
    5.         <item name="android:windowBackground">@android:color/transparentitem>
    6.         <item name="android:windowNoTitle">trueitem>
    7.         <item name="android:backgroundDimAmount">0.8item>
    8.     style>
    9. resources>

    弹窗ProgressDialog.java

    1. package com.suoer.ndk.ffmpegtestapplication;
    2.  
    3. import android.app.Dialog;
    4. import android.content.Context;
    5. import android.widget.ProgressBar;
    6. import android.widget.TextView;
    7.  
    8. import androidx.annotation.NonNull;
    9.  
    10.  
    11. public class ProgressDialog extends Dialog {
    12.  
    13.     private TextView tvProgress;
    14.     private ProgressBar compress_progressbar;
    15.  
    16.     public ProgressDialog(@NonNull Context context) {
    17.         this(context, R.style.normal_dialog);
    18.         setContentView(R.layout.dialog_progress);
    19.         tvProgress = findViewById(R.id.tv_dialog_compress_progress);
    20.         compress_progressbar =findViewById(R.id.compress_progressbar);
    21.     }
    22.  
    23.     private ProgressDialog(@NonNull Context context, int themeResId) {
    24.         super(context, themeResId);
    25.     }
    26.  
    27.     public void setProgress(int progress) {
    28.         if (progress < 0) {
    29.             progress = 0;
    30.         } else if (progress > 100) {
    31.             progress = 100;
    32.         }
    33.  
    34.         tvProgress.setText(progress + "%");
    35.         compress_progressbar.setProgress(progress);
    36.     }
    37. }

    最终的MainActivity.java

    1. package com.suoer.ndk.ffmpegtestapplication;
    2.  
    3. import android.Manifest;
    4. import android.os.Bundle;
    5. import android.os.Environment;
    6. import android.util.Log;
    7. import android.view.View;
    8. import android.widget.TextView;
    9. import android.widget.Toast;
    10.  
    11. import com.tbruyelle.rxpermissions3.RxPermissions;
    12.  
    13. import java.io.File;
    14.  
    15. import androidx.appcompat.app.AppCompatActivity;
    16. import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
    17. import io.reactivex.rxjava3.core.Observable;
    18. import io.reactivex.rxjava3.functions.Consumer;
    19. import io.reactivex.rxjava3.functions.Function;
    20. import io.reactivex.rxjava3.schedulers.Schedulers;
    21.  
    22. public class MainActivity extends AppCompatActivity {
    23.     private File mInFile=new File(Environment.getExternalStorageDirectory(),"test.mp4");//mInFile 需要压缩的文件路径
    24.     private File mOutFile=new File(Environment.getExternalStorageDirectory(),"out.mp4");//mOutFile压缩后的文件路径
    25.     private ProgressDialog mProgressDialog;//进度弹窗
    26.     // Used to load the 'native-lib' library on application startup.
    27.     static {
    28.         System.loadLibrary("native-lib");
    29.     }
    30.  
    31.     @Override
    32.     protected void onCreate(Bundle savedInstanceState) {
    33.         super.onCreate(savedInstanceState);
    34.         setContentView(R.layout.activity_main);
    35.         if (mProgressDialog == null) {
    36.             mProgressDialog = new ProgressDialog(this);
    37.         }
    38.         mProgressDialog.setCancelable(false);
    39.         mProgressDialog.setProgress(0);
    40.         // Example of a call to a native method
    41.         TextView tv = findViewById(R.id.sample_text);
    42.         //tv.setText("ffmpeg版本："+stringFromJNI());
    43.         tv.setText("压缩");
    44.  
    45.  
    46.         //tv的点击事件 点击按钮实现视频压缩
    47.         tv.setOnClickListener(new View.OnClickListener() {
    48.             @Override
    49.             public void onClick(View v) {
    50.                 // 压缩文件 需要读写文件权限 申请权限
    51.                 RxPermissions rxPermissions=new RxPermissions(MainActivity.this);
    52.                 rxPermissions.request(Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE).subscribe(new Consumer() {
    53.             @Override
    54.             public void accept(Boolean aBoolean) throws Throwable {
    55.                 if(aBoolean){
    56.                     //权限已经获取 压缩视频
    57.                     //如果手机中不存在test.mp4的文件则提示
    58.                     if(!mInFile.exists()){
    59.                         Toast.makeText(MainActivity.this,"请把assert目录中的test.mp4拷贝至手机中！",Toast.LENGTH_LONG).show();
    60.                         return;
    61.                     }
    62.                     if(mOutFile.exists()){
    63.                         mOutFile.delete();
    64.                     }
    65.  
    66.                     compressVideo();
    67.                 }
    68.             }
    69.         });
    70.             }
    71.         });
    72.     }
    73.  
    74.     /**
    75.      * 开启子线程处理耗时压缩问题
    76.      */
    77.  
    78.     private void compressVideo() {
    79.  
    80.         //ffmpeg的压缩命令:ffmpeg -i test.mp4 -b:v 1024k out.mp4
    81.         //ffmpeg -i test.mp4 -b:v 1024k out.mp4
    82.         //-b:v 1024k 1024k为码率 码率越高视频越清晰，而且视频越大
    83.         //test.mp4需要压缩的文件
    84.         //out.mp4 压缩之后的文件
    85.         if(mProgressDialog!=null&&!mProgressDialog.isShowing()){
    86.             mProgressDialog.show();
    87.         }
    88.  
    89.         String[] compressCommand={"ffmpeg","-i",mInFile.getAbsolutePath(),"-b:v","1024k",mOutFile.getAbsolutePath()};
    90.         //压缩是耗时的，需要子线程处理
    91.         Observable.just(compressCommand).map(new Function() {
    92.             @Override
    93.             public File apply(String[] compressCommand) throws Throwable {
    94.                 //子线程
    95.                 VideoCompress videoCompress=new VideoCompress();
    96.                 videoCompress.compressVideo(compressCommand, new VideoCompress.CompressCallback() {
    97.                     @Override
    98.                     public void onCompress(int current, int total) {
    99.                         Log.e("TAG", "onCompress: 压缩进度:"+current+"/"+total);
    100.                         runOnUiThread(new Runnable() {
    101.                             @Override
    102.                             public void run() {
    103.                                 if(mProgressDialog!=null){
    104.                                    mProgressDialog.setProgress(100 * current / total);
    105.                                 }
    106.                             }
    107.                         });
    108.  
    109.                     }
    110.                 });
    111.                 return mOutFile;
    112.             }
    113.         }).subscribeOn(Schedulers.io())
    114.         .observeOn(AndroidSchedulers.mainThread())
    115.         .subscribe(new Consumer() {
    116.             @Override
    117.             public void accept(File file) throws Throwable {
    118.                 // 主线程 压缩完成
    119.                 Log.e("TAG", "accept: 压缩完成！" );
    120.  
    121.                 if(mProgressDialog!=null){
    122.                     mProgressDialog.dismiss();
    123.                 }
    124.             }
    125.         });
    126.  
    127.  
    128.     }
    129.  
    130.  
    131.  
    132.     /**
    133.      * A native method that is implemented by the 'native-lib' native library,
    134.      * which is packaged with this application.
    135.      */
    136.     public native String stringFromJNI();
    137.  
    138.     @Override
    139.     protected void onDestroy() {
    140.         super.onDestroy();
    141.         if (mProgressDialog != null) {
    142.             mProgressDialog.cancel();
    143.             mProgressDialog = null;
    144.         }
    145.     }
    146. }

  • 相关阅读:
    Python实验项目6 ：文件操作与模块化
    使用HTML制作一个端午赛龙舟小游戏
    python 获取下载文件的后缀
    IDEA 新建 Maven 项目没有文件结构 pom 文件为空 解决方法
    QT项目：网络聊天室
    springcloud - ribbon 饥饿加载
    云栖大会，未来万物皆是计算机？
    【AI应用探讨】—知识图谱（KG）应用场景
    MAC帧
    【U8+】用友U8+客户端登录账套的时候， 提示： 已成功与服务器建立连接，但是在登录过程中发生错误； 指定的网络名不再可用。
  • 原文地址：https://blog.csdn.net/Jushuzhan/article/details/126497340