Newest 'ffmpeg' Questions - Stack Overflow

http://stackoverflow.com/questions/tagged/ffmpeg

Les articles publiés sur le site

  • Using PHP-FFMPEG to crossfade audio

    18 juillet 2016, par jreikes

    I already know how to do this in FFMPEG from the command line, but was hoping I could do it all using the PHP-FFMPEG wrapper. I have two files: video.mpeg (let's say it's a video that's 5 seconds in length) and fade_in.aac (this is a 0.5 second audio clip that is supposed to overlap with the beginning of video.mpeg).

    I want to crossfade audio.aac at the beginning of video.mpeg (so audio.aac starts at full volume and fades out for 0.5 seconds, video.mpeg starts at no volume and fades in during the first 0.5 seconds).

    In the command line, I would do something like the following:

    #First, strip the audio away from the video file
    ffmpeg -i video.mpeg audio.aac
    
    #Next, perform the crossfade operation
    ffmpeg -i fade_in.aac -i audio.aac -filter_complex "[a1][a2]acrossfade=d=0.5" audio_w_crossfade.aac
    
    #Finally, recombine the audio with the video file
    ffmpeg -i video.mpeg -i audio_w_crossfade.aac -codec copy -shortest video_w_crossfade.mpeg
    

    Is there a way to do this with the PHP-FFMPEG wrapper library?

  • Screen Capture with FFMPEG and Google Native Client

    18 juillet 2016, par Mohammad Abu Musa

    I am building a screen recorder that is based on Native Client for Google, I have ffmpeg installed and ready but I do not have experience programming in ffmpeg. so I am looking for tips to understand how to build this recorder.

    My goal is to make a screen recorder and export videos as webm files, I have all the required libraries I just could not find any code examples to hack on

    This is what I achieved so far

    #define __STDC_LIMIT_MACROS
    
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    
    #include "ppapi/cpp/instance.h"
    #include "ppapi/cpp/var_dictionary.h"
    #include "ppapi/c/pp_errors.h"
    #include "ppapi/c/ppb_console.h"
    #include "ppapi/cpp/input_event.h"
    #include "ppapi/cpp/module.h"
    #include "ppapi/cpp/rect.h"
    #include "ppapi/cpp/var.h"
    #include "ppapi/cpp/var_array_buffer.h"
    
    // Begin File IO headers
    #include "ppapi/c/pp_stdint.h"
    #include "ppapi/c/ppb_file_io.h"
    #include "ppapi/cpp/directory_entry.h"
    #include "ppapi/cpp/file_io.h"
    #include "ppapi/cpp/file_ref.h"
    #include "ppapi/cpp/file_system.h"
    #include "ppapi/cpp/instance.h"
    #include "ppapi/cpp/message_loop.h"
    #include "ppapi/cpp/module.h"
    #include "ppapi/cpp/var.h"
    #include "ppapi/cpp/var_array.h"
    #include "ppapi/utility/completion_callback_factory.h"
    #include "ppapi/utility/threading/simple_thread.h"
    
    #ifndef INT32_MAX
    #define INT32_MAX (0x7FFFFFFF)
    #endif
    
    #ifdef WIN32
    #undef min
    #undef max
    #undef PostMessage
    
    // Allow 'this' in initializer list
    #pragma warning(disable : 4355)
    #endif
    
    namespace {
    typedef std::vector StringVector;
    }
    //End File IO headers
    
    extern "C" {
    #include avcodec.h>
    #include swscale.h>
    #include avformat.h>
    #include imgutils.h>
    }
    
    const char* file_name = "/file.txt";
    const char* video_name = "/video.mpeg";
    const char* file_text = "Echo from NaCl: ";
    
    /**
     * Pixel formats and codecs
     */
    static const AVPixelFormat sourcePixelFormat = AV_PIX_FMT_BGR24;
    static const AVPixelFormat destPixelFormat = AV_PIX_FMT_YUV420P;
    static const AVCodecID destCodec = AV_CODEC_ID_MPEG2VIDEO;
    
    class RecorderInstance: public pp::Instance {
    public:
        explicit RecorderInstance(PP_Instance instance) :
                pp::Instance(instance), callback_factory_(this), file_system_(this,
                        PP_FILESYSTEMTYPE_LOCALPERSISTENT), file_system_ready_(
                        false), file_thread_(this) {
        }
    
        virtual ~RecorderInstance() {
            file_thread_.Join();
        }
    
        virtual bool Init(uint32_t /*argc*/, const char * /*argn*/[],
                const char * /*argv*/[]) {
            file_thread_.Start();
            file_thread_.message_loop().PostWork(
                    callback_factory_.NewCallback(
                            &RecorderInstance::OpenFileSystem));
            avcodec_register_all(); // mandatory to register ffmpeg functions
    
            return true;
        }
    
    private:
        pp::CompletionCallbackFactory callback_factory_;
        pp::FileSystem file_system_;
    
        // Indicates whether file_system_ was opened successfully. We only read/write
        // this on the file_thread_.
        bool file_system_ready_;
        pp::SimpleThread file_thread_;
    
        virtual void HandleMessage(const pp::Var& var_message) {
            if (!var_message.is_dictionary()) {
                LogToConsole(PP_LOGLEVEL_ERROR, pp::Var("Invalid message!"));
                return;
            }
    
            pp::VarDictionary dict_message(var_message);
            std::string command = dict_message.Get("message").AsString();
    
    
            if (command == "sendFrame") {
                pp::VarArrayBuffer data(dict_message.Get("data"));
                uint width = 600;
                uint height = 800;
                uint8_t endcode[] = { 0, 0, 1, 0xb7 };
                /**
                 * Create an encoder and open it
                 */
                avcodec_register_all();
    
                AVCodec *h264encoder = avcodec_find_encoder(destCodec);
                AVCodecContext *h264encoderContext = avcodec_alloc_context3(
                        h264encoder);
    
                h264encoderContext->pix_fmt = destPixelFormat;
                h264encoderContext->width = width;
                h264encoderContext->height = height;
    
                if (avcodec_open2(h264encoderContext, h264encoder, NULL) < 0) {
                    ShowErrorMessage("Cannot open codec" ,-1);
                    return;
                }
    
                /**
                 * Create a stream
                 */
                AVFormatContext *cv2avFormatContext = avformat_alloc_context();
                AVStream *h264outputstream = avformat_new_stream(cv2avFormatContext,
                        h264encoder);
    
                AVFrame *sourceAvFrame = av_frame_alloc(), *destAvFrame =
                        av_frame_alloc();
                int got_frame;
    
                FILE* videoOutFile = fopen("video", "wb");
                /**
                 * Prepare the conversion context
                 */
                SwsContext *bgr2yuvcontext = sws_getContext(width, height,
                        sourcePixelFormat, width, height, destPixelFormat,
                        SWS_BICUBIC, NULL, NULL, NULL);
    
                int framesToEncode = 100;
                /**
                 * Convert and encode frames
                 */
                for (uint i = 0; i < framesToEncode; i++) {
    
                    /**
                     * Allocate source frame, i.e. input to sws_scale()
                     */
                    av_image_alloc(sourceAvFrame->data, sourceAvFrame->linesize,
                            width, height, sourcePixelFormat, 1);
    
                    /**
                     * Copy image data into AVFrame from cv::Mat
                     */
                    for (uint32_t h = 0; h < height; h++)
                        memcpy(
                                &(sourceAvFrame->data[0][h
                                        * sourceAvFrame->linesize[0]]),
                                &(data), width * 3);
    
                    /**
                     * Allocate destination frame, i.e. output from sws_scale()
                     */
                    av_image_alloc(destAvFrame->data, destAvFrame->linesize, width,
                            height, destPixelFormat, 1);
    
                    sws_scale(bgr2yuvcontext, sourceAvFrame->data,
                            sourceAvFrame->linesize, 0, height, destAvFrame->data,
                            destAvFrame->linesize);
                    sws_freeContext(bgr2yuvcontext);
                    /**
                     * Prepare an AVPacket and set buffer to NULL so that it'll be allocated by FFmpeg
                     */
                    AVPacket avEncodedPacket;
                    av_init_packet(&avEncodedPacket);
                    avEncodedPacket.data = NULL;
                    avEncodedPacket.size = 0;
    
                    destAvFrame->pts = i;
                    avcodec_encode_video2(h264encoderContext, &avEncodedPacket,
                            destAvFrame, &got_frame);
    
                    if (got_frame) {
                        ShowErrorMessage(
                                "Encoded a frame of size \n",-1); //+ (string)avEncodedPacket.size + "\n");
    
                        if (fwrite(avEncodedPacket.data, 1, avEncodedPacket.size,
                                videoOutFile) < (unsigned) avEncodedPacket.size)
                            ShowErrorMessage(
                                    "Could not write all \n",-1);
                                    //+ avEncodedPacket.size
                                            //+ " bytes, but will continue..\n"
    
    
                        fflush(videoOutFile);
    
                    }
                    /**
                     * Per-frame cleanup
                     */
                    av_packet_free_side_data(&avEncodedPacket);
                    av_free_packet(&avEncodedPacket);
                    av_freep(sourceAvFrame->data);
                    av_frame_free(&sourceAvFrame);
                    av_freep(destAvFrame->data);
                    av_frame_free(&destAvFrame);
    
                }
    
                fwrite(endcode, 1, sizeof(endcode), videoOutFile);
                fclose(videoOutFile);
    
                /**
                 * Final cleanup
                 */
                avformat_free_context(cv2avFormatContext);
                avcodec_close(h264encoderContext);
                avcodec_free_context(&h264encoderContext);
    
            } else if (command == "createFile") {
                file_thread_.message_loop().PostWork(
                        callback_factory_.NewCallback(&RecorderInstance::Save,
                                file_name, file_text));
            }
        }
    
    
        void OpenFileSystem(int32_t /* result */) {
            int32_t rv = file_system_.Open(1024 * 1024, pp::BlockUntilComplete());
            if (rv == PP_OK) {
                file_system_ready_ = true;
                // Notify the user interface that we're ready
                ShowStatusMessage("STORAGE READY");
            } else {
                ShowErrorMessage("Failed to open file system", rv);
            }
        }
    
        void Save(int32_t /* result */, const std::string& file_name,
                const std::string& file_contents) {
            if (!file_system_ready_) {
                ShowErrorMessage("File system is not open", PP_ERROR_FAILED);
                return;
            }
            pp::FileRef ref(file_system_, file_name.c_str());
            pp::FileIO file(this);
    
            int32_t open_result = file.Open(ref,
                    PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE
                            | PP_FILEOPENFLAG_TRUNCATE, pp::BlockUntilComplete());
            if (open_result != PP_OK) {
                ShowErrorMessage("File open for write failed", open_result);
                return;
            }
    
            // We have truncated the file to 0 bytes. So we need only write if
            // file_contents is non-empty.
            if (!file_contents.empty()) {
                if (file_contents.length() > INT32_MAX) {
                    ShowErrorMessage("File too big", PP_ERROR_FILETOOBIG);
                    return;
                }
                int64_t offset = 0;
                int32_t bytes_written = 0;
                do {
                    bytes_written = file.Write(offset,
                            file_contents.data() + offset, file_contents.length(),
                            pp::BlockUntilComplete());
                    if (bytes_written > 0) {
                        offset += bytes_written;
                    } else {
                        ShowErrorMessage("File write failed", bytes_written);
                        return;
                    }
                } while (bytes_written
                        < static_cast(file_contents.length()));
            }
            // All bytes have been written, flush the write buffer to complete
            int32_t flush_result = file.Flush(pp::BlockUntilComplete());
            if (flush_result != PP_OK) {
                ShowErrorMessage("File fail to flush", flush_result);
                return;
            }
            ShowStatusMessage("Save success");
        }
    
        /// Encapsulates our simple javascript communication protocol
        void ShowErrorMessage(const std::string& message, int32_t result) {
            std::stringstream ss;
            ss << "ERROR: " << message << " -- Error #: " << result << "\n";
            PostMessage(ss.str());
        }
    
        void ShowStatusMessage(const std::string& message) {
            std::stringstream ss;
            ss << "LOG: " << message << "\n";
            PostMessage(ss.str());
        }
    
    };
    
    class RecorderModule: public pp::Module {
    public:
        RecorderModule() :
                pp::Module() {
        }
    
        virtual ~RecorderModule() {
        }
    
        virtual pp::Instance* CreateInstance(PP_Instance instance) {
            return new RecorderInstance(instance);
        }
    };
    
    namespace pp {
    
    /**
     * This function is an entry point to a NaCl application.
     * It must be implemented.
     */
    Module* CreateModule() {
        return new RecorderModule();
    }
    
    }  // namespace pp
    
  • can i concat with ffmpg from list inside list ?

    18 juillet 2016, par Nir Diamant

    i have 6 movies in 2 different lists.

    can i give link from one list to the other one ?

    i have mylist1.txt:
    file 'C:\videos\vid1.avi' 
    file 'C:\videos\vid4.avi' 
    file 'C:\videos\vid5.avi' 
    
    and i have mylist2:
    file 'C:\videos\vid2.avi' 
    file 'C:\videos\vid3.avi' 
    

    ** they created dynamically, this why they are separate

    any way, i want to make one movie that the order will be: vid1+vid2+vid3+vid4+vid5

    can i do something like this:

    ffmpeg -f concat -i mylist.txt -c copy output.mp4
    
        while mylist.txt:
        file 'C:\videos\vid1.avi' 
        mylist2.txt
        file 'C:\videos\vid4.avi' 
        file 'C:\videos\vid5.avi' 
    
  • ffmpeg out of memory, loads every video in memory

    18 juillet 2016, par 7927412

    When i convert a video it is loaded in the memory. After few videos the memory is full and ffmpeg throws the error "out of memory". How can i remove the converted video out of memory?

  • FFmpeg - mapping 4 audio channels to 1 audio track

    18 juillet 2016, par Avalon

    I have two QT MOV's that I want to concatenate using FFmpeg, but I am having trouble understanding how to map the audio channels.

    First MOV has 2 channels, Front Left and Front Right. Second MOV has 4 channels, Front Left, Front Right, Side Left and Side Right.

    How do I create 1 audio track with 4 channels mapped as FL, FR, SL and SR?

    MediaInfo reports the following (not desired result):

    Audio #1
    ID                                       : 2
    Format                                   : AAC
    Format/Info                              : Advanced Audio Codec
    Format profile                           : LC
    Codec ID                                 : 40
    Duration                                 : 4mn 35s
    Bit rate mode                            : Variable
    Bit rate                                 : 126 Kbps
    Maximum bit rate                         : 160 Kbps
    Channel(s)                               : 2 channels
    Channel(s)_Original                      : 4 channels
    Channel positions                        : Front: L C R, Side: C
    Sampling rate                            : 48.0 KHz
    Frame rate                               : 46.875 fps (1024 spf)
    Compression mode                         : Lossy
    Stream size                              : 4.14 MiB (12%)
    Default                                  : Yes
    Alternate group                          : 1
    
    Audio #2
    ID                                       : 3
    Format                                   : AAC
    Format/Info                              : Advanced Audio Codec
    Format profile                           : LC
    Codec ID                                 : 40
    Duration                                 : 4mn 35s
    Bit rate mode                            : Variable
    Bit rate                                 : 127 Kbps
    Maximum bit rate                         : 160 Kbps
    Channel(s)                               : 2 channels
    Channel(s)_Original                      : 4 channels
    Channel positions                        : Front: L C R, Side: C
    Sampling rate                            : 48.0 KHz
    Frame rate                               : 46.875 fps (1024 spf)
    Compression mode                         : Lossy
    Stream size                              : 4.18 MiB (12%)
    Default                                  : No
    Alternate group                          : 1
    
    Audio #3
    ID                                       : 4
    Format                                   : AAC
    Format/Info                              : Advanced Audio Codec
    Format profile                           : LC
    Codec ID                                 : 40
    Duration                                 : 4mn 35s
    Bit rate mode                            : Variable
    Bit rate                                 : 110 Kbps
    Maximum bit rate                         : 160 Kbps
    Channel(s)                               : 2 channels
    Channel(s)_Original                      : 4 channels
    Channel positions                        : Front: L C R, Side: C
    Sampling rate                            : 48.0 KHz
    Frame rate                               : 46.875 fps (1024 spf)
    Compression mode                         : Lossy
    Stream size                              : 3.62 MiB (10%)
    Default                                  : No
    Alternate group                          : 1
    
    Audio #4
    ID                                       : 5
    Format                                   : AAC
    Format/Info                              : Advanced Audio Codec
    Format profile                           : LC
    Codec ID                                 : 40
    Duration                                 : 4mn 35s
    Bit rate mode                            : Variable
    Bit rate                                 : 110 Kbps
    Maximum bit rate                         : 160 Kbps
    Channel(s)                               : 2 channels
    Channel(s)_Original                      : 4 channels
    Channel positions                        : Front: L C R, Side: C
    Sampling rate                            : 48.0 KHz
    Frame rate                               : 46.875 fps (1024 spf)
    Compression mode                         : Lossy
    Stream size                              : 3.61 MiB (10%)
    Default                                  : No
    Alternate group                          : 1
    

    FFmpeg command is as follows:

    `ffmpeg -i "2chan.mov" -i "4chan.mov" -filter_complex "[0:v] [0:a] [1:v] [1:a] concat=n=2:v=1:a=1 [v] [a]; [v]scale=-1:288[v2]; [a]channelsplit=channel_layout=quad(side)[FL][FR][SL][SR]" -map "[v2]" -map "[FL]" -map "[FR]" -map "[SL]" -map "[SR]" -c:v libx264 -pix_fmt yuv420p -b:v 700k -minrate 700k -maxrate 700k -bufsize 700k -r 25 -sc_threshold 25 -keyint_min 25 -g 25 -qmin 3 -qmax 51 -threads 8 -c:a aac -strict -2 -b:a 160k -ar 48000 -async 1 -ac 4 combined.mp4`
    

    Console output:

      ffmpeg version N-77883-gd7c75a5 Copyright (c) 2000-2016 the FFmpeg developers
          built with gcc 5.2.0 (GCC)
          configuration: --enable-gpl --enable-version3 --disable-w32threads --enable-av
        isynth --enable-bzlib --enable-fontconfig --enable-frei0r --enable-gnutls --enab
        le-iconv --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --
        enable-libdcadec --enable-libfreetype --enable-libgme --enable-libgsm --enable-l
        ibilbc --enable-libmodplug --enable-libmp3lame --enable-libopencore-amrnb --enab
        le-libopencore-amrwb --enable-libopenjpeg --enable-libopus --enable-librtmp --en
        able-libschroedinger --enable-libsoxr --enable-libspeex --enable-libtheora --ena
        ble-libtwolame --enable-libvidstab --enable-libvo-aacenc --enable-libvo-amrwbenc
         --enable-libvorbis --enable-libvpx --enable-libwavpack --enable-libwebp --enabl
        e-libx264 --enable-libx265 --enable-libxavs --enable-libxvid --enable-libzimg --
        enable-lzma --enable-decklink --enable-zlib
          libavutil      55. 13.100 / 55. 13.100
          libavcodec     57. 22.100 / 57. 22.100
          libavformat    57. 21.101 / 57. 21.101
          libavdevice    57.  0.100 / 57.  0.100
          libavfilter     6. 25.100 /  6. 25.100
          libswscale      4.  0.100 /  4.  0.100
          libswresample   2.  0.101 /  2.  0.101
          libpostproc    54.  0.100 / 54.  0.100
        [mov,mp4,m4a,3gp,3g2,mj2 @ 0000000000575c00] ignoring 'frma' atom of 'mp4a', str
    eam format is 'mp4a'
    Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '2chan.mov':
      Metadata:
        major_brand     : qt
        minor_version   : 537199360
        compatible_brands: qt
        creation_time   : 2016-01-19 05:48:38
      Duration: 00:00:45.00, start: 0.000000, bitrate: 364 kb/s
        Stream #0:0(eng): Video: h264 (Main) (avc1 / 0x31637661), yuv420p(tv, smpte1
    70m/smpte170m/bt709), 768x576, 196 kb/s, SAR 1:1 DAR 4:3, 25 fps, 25 tbr, 25 tbn
    , 50 tbc (default)
        Metadata:
          creation_time   : 2016-01-19 05:48:40
          handler_name    : Apple Alias Data Handler
          encoder         : H.264
          timecode        : 00:00:00:00
        Stream #0:1(eng): Audio: aac (LC) (mp4a / 0x6134706D), 48000 Hz, stereo, flt
    p, 159 kb/s (default)
        Metadata:
          creation_time   : 2016-01-19 05:48:42
          handler_name    : Apple Alias Data Handler
          timecode        : 00:00:00:00
        Stream #0:2(eng): Data: none (tmcd / 0x64636D74) (default)
        Metadata:
          creation_time   : 2016-01-19 05:49:42
          handler_name    : Apple Alias Data Handler
          timecode        : 00:00:00:00
    [mov,mp4,m4a,3gp,3g2,mj2 @ 00000000005da420] ignoring 'frma' atom of 'mp4a', str
    eam format is 'mp4a'
    Input #1, mov,mp4,m4a,3gp,3g2,mj2, from '4chan.mov':
      Metadata:
        major_brand     : qt
        minor_version   : 537199360
        compatible_brands: qt
        creation_time   : 2016-01-19 04:11:52
      Duration: 00:19:58.00, start: 0.000000, bitrate: 5118 kb/s
        Stream #1:0(eng): Video: h264 (Main) (avc1 / 0x31637661), yuv420p(tv, smpte1
    70m/smpte170m/bt709), 768x576, 4955 kb/s, 25 fps, 25 tbr, 25k tbn, 50k tbc (defa
    ult)
        Metadata:
          creation_time   : 2016-01-19 04:11:52
          handler_name    : Apple Alias Data Handler
          encoder         : H.264
          timecode        : 00:28:33:21
        Stream #1:1(eng): Audio: aac (LC) (mp4a / 0x6134706D), 48000 Hz, quad, fltp,
     157 kb/s (default)
        Metadata:
          creation_time   : 2016-01-19 04:11:52
          handler_name    : Apple Alias Data Handler
        Stream #1:2(eng): Data: none (tmcd / 0x64636D74), 0 kb/s
        Metadata:
          rotate          : 0
          creation_time   : 2016-01-19 04:11:52
          handler_name    : Apple Alias Data Handler
          timecode        : 00:28:33:21
    File 'Output_Complex_6.mp4' already exists. Overwrite ? [y/N] y
    -async is forwarded to lavfi similarly to -af aresample=async=1:min_hard_comp=0.
    100000:first_pts=0.
        Last message repeated 1 times
    [libx264 @ 000000000057d260] using SAR=1/1
    [libx264 @ 000000000057d260] using cpu capabilities: MMX2 SSE2Fast SSSE3 Cache64
     SlowShuffle
    [libx264 @ 000000000057d260] profile High, level 2.1
    [libx264 @ 000000000057d260] 264 - core 148 r2638 7599210 - H.264/MPEG-4 AVC cod
    ec - Copyleft 2003-2015 - http://www.videolan.org/x264.html - options: cabac=1 r
    ef=3 deblock=1:0:0 analyse=0x3:0x113 me=hex subme=7 psy=1 psy_rd=1.00:0.00 mixed
    _ref=1 me_range=16 chroma_me=1 trellis=1 8x8dct=1 cqm=0 deadzone=21,11 fast_pski
    p=1 chroma_qp_offset=-2 threads=8 lookahead_threads=1 sliced_threads=0 nr=0 deci
    mate=1 interlaced=0 bluray_compat=0 constrained_intra=0 bframes=3 b_pyramid=2 b_
    adapt=1 b_bias=0 direct=1 weightb=1 open_gop=0 weightp=2 keyint=25 keyint_min=13
     scenecut=25 intra_refresh=0 rc_lookahead=25 rc=cbr mbtree=1 bitrate=700 ratetol
    =1.0 qcomp=0.60 qpmin=3 qpmax=51 qpstep=4 vbv_maxrate=700 vbv_bufsize=700 nal_hr
    d=none filler=0 ip_ratio=1.40 aq=1:1.00
    Output #0, mp4, to 'Output_Complex_6.mp4':
      Metadata:
        major_brand     : qt
        minor_version   : 537199360
        compatible_brands: qt
        title           : TestTitle
        encoder         : Lavf57.21.101
        Stream #0:0: Video: h264 (libx264) ([33][0][0][0] / 0x0021), yuv420p, 384x28
    8 [SAR 1:1 DAR 4:3], q=3-51, 700 kb/s, 25 fps, 12800 tbn, 25 tbc (default)
        Metadata:
          encoder         : Lavc57.22.100 libx264
        Side data:
          unknown side data type 10 (24 bytes)
        Stream #0:1: Audio: aac (LC) ([64][0][0][0] / 0x0040), 48000 Hz, 4.0, fltp,
    160 kb/s
        Metadata:
          encoder         : Lavc57.22.100 aac
        Stream #0:2: Audio: aac (LC) ([64][0][0][0] / 0x0040), 48000 Hz, 4.0, fltp,
    160 kb/s
        Metadata:
          encoder         : Lavc57.22.100 aac
        Stream #0:3: Audio: aac (LC) ([64][0][0][0] / 0x0040), 48000 Hz, 4.0, fltp,
    160 kb/s
        Metadata:
          encoder         : Lavc57.22.100 aac
        Stream #0:4: Audio: aac (LC) ([64][0][0][0] / 0x0040), 48000 Hz, 4.0, fltp,
    160 kb/s
        Metadata:
          encoder         : Lavc57.22.100 aac
    Stream mapping:
      Stream #0:0 (h264) -> concat:in0:v0
      Stream #0:1 (aac) -> concat:in0:a0
      Stream #1:0 (h264) -> concat:in1:v0
      Stream #1:1 (aac) -> concat:in1:a0
      scale -> Stream #0:0 (libx264)
      channelsplit:FL -> Stream #0:1 (aac)
      channelsplit:FR -> Stream #0:2 (aac)
      channelsplit:SL -> Stream #0:3 (aac)
      channelsplit:SR -> Stream #0:4 (aac)
    Press [q] to stop, [?] for help
    frame=   85 fps=0.0 q=3.0 size=       6kB time=00:00:02.68 bitrate=  18.8kbits/s
    frame=  150 fps=148 q=3.0 size=      14kB time=00:00:05.24 bitrate=  21.3kbits/s
    frame=  198 fps=130 q=3.0 size=      65kB time=00:00:07.21 bitrate=  74.4kbits/s
    frame=  238 fps=118 q=3.0 size=     125kB time=00:00:08.78 bitrate= 116.2kbits/s
    frame=  271 fps=108 q=3.0 size=     171kB time=00:00:10.09 bitrate= 138.9kbits/s
    frame=  304 fps=100 q=3.0 size=     218kB time=00:00:11.45 bitrate= 156.0kbits/s
    frame=  339 fps= 96 q=3.0 size=     268kB time=00:00:12.84 bitrate= 171.0kbits/s
    frame=  372 fps= 93 q=-1.0 Lsize=     376kB time=00:00:14.80 bitrate= 208.0kbits
    /s speed=3.69x
    video:27kB audio:319kB subtitle:0kB other streams:0kB global headers:0kB muxing
    overhead: 8.551113%
    [libx264 @ 000000000057d260] frame I:15    Avg QP: 3.01  size:  1370
    [libx264 @ 000000000057d260] frame P:90    Avg QP: 3.00  size:    24
    [libx264 @ 000000000057d260] frame B:267   Avg QP: 3.00  size:    17
    [libx264 @ 000000000057d260] consecutive B-frames:  4.3%  0.0%  0.0% 95.7%
    [libx264 @ 000000000057d260] mb I  I16..4: 95.8%  0.0%  4.2%
    [libx264 @ 000000000057d260] mb P  I16..4:  0.0%  0.0%  0.0%  P16..4:  0.1%  0.0
    %  0.0%  0.0%  0.0%    skip:99.9%
    [libx264 @ 000000000057d260] mb B  I16..4:  0.0%  0.0%  0.0%  B16..8:  0.0%  0.0
    %  0.0%  direct: 0.0%  skip:100.0%  L0: 0.0% L1:100.0% BI: 0.0%
    [libx264 @ 000000000057d260] 8x8 transform intra:0.0% inter:50.0%
    [libx264 @ 000000000057d260] coded y,uvDC,uvAC intra: 3.1% 8.8% 8.2% inter: 0.0%
     0.0% 0.0%
    [libx264 @ 000000000057d260] i16 v,h,dc,p: 90%  5%  5%  0%
    [libx264 @ 000000000057d260] i4 v,h,dc,ddl,ddr,vr,hd,vl,hu: 46% 29% 23%  0%  0%
     0%  0%  0%  0%
    [libx264 @ 000000000057d260] i8c dc,h,v,p: 76%  7% 17%  0%
    [libx264 @ 000000000057d260] Weighted P-Frames: Y:0.0% UV:0.0%
    [libx264 @ 000000000057d260] kb/s:14.64
    [aac @ 0000000000578320] Qavg: 65394.652
    [aac @ 0000000000593020] Qavg: 65473.359
    [aac @ 0000000000593940] Qavg: 65536.000
    [aac @ 0000000000594260] Qavg: 65536.000
    Exiting normally, received signal 2.
    Terminate batch job (Y/N)? Y