Recherche avancée

Médias (1)

Mot : - Tags -/punk

Autres articles (43)

  • List of compatible distributions

    26 avril 2011, par

    The table below is the list of Linux distributions compatible with the automated installation script of MediaSPIP. Distribution nameVersion nameVersion number Debian Squeeze 6.x.x Debian Weezy 7.x.x Debian Jessie 8.x.x Ubuntu The Precise Pangolin 12.04 LTS Ubuntu The Trusty Tahr 14.04
    If you want to help us improve this list, you can provide us access to a machine whose distribution is not mentioned above or send the necessary fixes to add (...)

  • Formulaire personnalisable

    21 juin 2013, par

    Cette page présente les champs disponibles dans le formulaire de publication d’un média et il indique les différents champs qu’on peut ajouter. Formulaire de création d’un Media
    Dans le cas d’un document de type média, les champs proposés par défaut sont : Texte Activer/Désactiver le forum ( on peut désactiver l’invite au commentaire pour chaque article ) Licence Ajout/suppression d’auteurs Tags
    On peut modifier ce formulaire dans la partie :
    Administration > Configuration des masques de formulaire. (...)

  • Amélioration de la version de base

    13 septembre 2013

    Jolie sélection multiple
    Le plugin Chosen permet d’améliorer l’ergonomie des champs de sélection multiple. Voir les deux images suivantes pour comparer.
    Il suffit pour cela d’activer le plugin Chosen (Configuration générale du site > Gestion des plugins), puis de configurer le plugin (Les squelettes > Chosen) en activant l’utilisation de Chosen dans le site public et en spécifiant les éléments de formulaires à améliorer, par exemple select[multiple] pour les listes à sélection multiple (...)

Sur d’autres sites (5223)

  • FFMPEG concat demuxer - how to make file formats compatible ?

    10 avril 2015, par user206481

    I need to automate mp4 concatenation server-side and I’m using FFMPEG. I will get uploads of mp4 files and I want to attach a Title.mp4 and End.mp4 to each one. I am also overlaying a soundtrack (the input videos do not have sound) There is a potential high server load so I’d like to do it as efficiently as possible using ffmpeg’s concat demuxer to avoid re-encoding the video.

    After receiving samples of each file, I am not successful and I believe it is due to mismatched file formats. My result has good Title.mp4 and audio, then when the sample uploaded mp4 is supposed to play there is garbled green/pink/red pixels on the top half of the video, then the End.mp4 plays fine. Here is my ffmpeg command and output :

    $ ffmpeg -f concat -i <(printf "file '%s'\n" Title.mp4 Sample.mp4 End.mp4) -i SoundTrack.wav -c:v copy -strict -2 -y Out.mp4

    ffmpeg version 2.6.1 Copyright (c) 2000-2015 the FFmpeg developers
    built with gcc 4.1.2 (GCC) 20080704 (Red Hat 4.1.2-55)
    configuration: --prefix=/home/dpmsmobi/ffmpeg_build --extra-cflags=-I/home/dpmsmobi/ffmpeg_build/include --extra-ldflags=-L/home/dpmsmobi/ffmpeg_build/lib --bindir=/home/dpmsmobi/bin --enable-gpl --enable-nonfree --enable-libmp3lame --enable-libvorbis --enable-libvpx --enable-libx264
     libavutil      54. 20.100 / 54. 20.100
     libavcodec     56. 26.100 / 56. 26.100
     libavformat    56. 25.101 / 56. 25.101
     libavdevice    56.  4.100 / 56.  4.100
     libavfilter     5. 11.102 /  5. 11.102
     libswscale      3.  1.101 /  3.  1.101
     libswresample   1.  1.100 /  1.  1.100
     libpostproc    53.  3.100 / 53.  3.100
    Input #0, concat, from '/dev/fd/63':
     Duration: N/A, start: 0.000000, bitrate: 1810 kb/s
       Stream #0:0: Video: h264 (Main) (avc1 / 0x31637661), yuv420p(tv), 768x512 [SAR 1:1 DAR 3:2], 1810 kb/s, 30 fps, 30 tbr, 30k tbn, 60 tbc
    Guessed Channel Layout for  Input Stream #1.0 : stereo
    Input #1, wav, from 'SoundTrack.wav':
     Metadata:
       encoded_by      : Adobe Premiere Pro CC 2014 (Maci
       encoder         : Adobe Premiere Pro CC 2014 (Macintosh)
       date            : 2015-04-07
       creation_time   : 11:12:10
       time_reference  : 0
     Duration: 00:00:15.06, bitrate: 1551 kb/s
       Stream #1:0: Audio: pcm_s16le ([1][0][0][0] / 0x0001), 48000 Hz, 2 channels, s16, 1536 kb/s
    Output #0, mp4, to 'Out.mp4':
     Metadata:
       encoder         : Lavf56.25.101
       Stream #0:0: Video: h264 ([33][0][0][0] / 0x0021), yuv420p, 768x512 [SAR 1:1 DAR 3:2], q=2-31, 1810 kb/s, 30 fps, 30 tbr, 30k tbn, 30k tbc
       Stream #0:1: Audio: aac ([64][0][0][0] / 0x0040), 48000 Hz, stereo, fltp, 128 kb/s
       Metadata:
         encoder         : Lavc56.26.100 aac
    Stream mapping:
     Stream #0:0 -> #0:0 (copy)
     Stream #1:0 -> #0:1 (pcm_s16le (native) -> aac (native))
    Press [q] to stop, [?] for help
    [concat @ 0x1dedc20] Thread message queue blocking; consider raising the thread_queue_size option (current value: 8)
    [concat @ 0x1dedc20] DTS 69750 < 91000 out of order
    [mp4 @ 0x1f75060] Non-monotonous DTS in output stream 0:0; previous: 91000, current: 69750; changing to 91001. This may result in incorrect timestamps in the output file.

    <----- many more Non-monotonous DTS messages omitted here ---->

    frame=  427 fps=0.0 q=-1.0 Lsize=    4123kB time=00:00:15.06 bitrate=2242.5kbits/s    
    video:3873kB audio:236kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.344173%

    I can successfully concatenate the Title.mp4 to the End.mp4, and I can successfully concatenate two Sample.mp4 files, so I know I’ve got the ffmpeg command right. I can also successfully concat the files using the following ffmpeg command with filter_complex instead of concat demuxer (this takes considerably longer due to re-encoding) :

    ffmpeg -i Title.mp4 -i Sample.mp4 -i End.mp4 -i SoundTrack.wav -filter_complex '[0:0] [1:0] [2:0] concat=n=3:v=1 [v]' -map '[v]' -map 3:0 -crf 20 -strict -2 -y Out2.mp4

    Here is the MediaInfo output for each type of mp4 file :

    $ mediainfo Title.mp4
    General
    Complete name                            : Title.mp4
    Format                                   : MPEG-4
    Format profile                           : Base Media / Version 2
    Codec ID                                 : mp42
    File size                                : 693 KiB
    Duration                                 : 3s 100ms
    Overall bit rate mode                    : Variable
    Overall bit rate                         : 1 831 Kbps
    Encoded date                             : UTC 2015-04-07 19:15:03
    Tagged date                              : UTC 2015-04-07 19:15:03
    ©TIM                                     : 00:00:00:00
    ©TSC                                     : 30
    ©TSZ                                     : 1

    Video
    ID                                       : 1
    Format                                   : AVC
    Format/Info                              : Advanced Video Codec
    Format profile                           : Main@L3.1
    Format settings, CABAC                   : Yes
    Format settings, ReFrames                : 3 frames
    Codec ID                                 : avc1
    Codec ID/Info                            : Advanced Video Coding
    Duration                                 : 3s 100ms
    Bit rate mode                            : Variable
    Bit rate                                 : 1 811 Kbps
    Maximum bit rate                         : 3 000 Kbps
    Width                                    : 768 pixels
    Height                                   : 512 pixels
    Display aspect ratio                     : 3:2
    Frame rate mode                          : Constant
    Frame rate                               : 30.000 fps
    Standard                                 : NTSC
    Color space                              : YUV
    Chroma subsampling                       : 4:2:0
    Bit depth                                : 8 bits
    Scan type                                : Progressive
    Bits/(Pixel*Frame)                       : 0.154
    Stream size                              : 685 KiB (99%)
    Language                                 : English
    Encoded date                             : UTC 2015-04-07 19:15:03
    Tagged date                              : UTC 2015-04-07 19:15:03
    Color range                              : Limited

    $ mediainfo Sample.mp4
    General
    Complete name                            : Sample.mp4
    Format                                   : MPEG-4
    Format profile                           : Base Media
    Codec ID                                 : isom
    File size                                : 2.93 MiB
    Duration                                 : 7s 9ms
    Overall bit rate                         : 3 505 Kbps
    Encoded date                             : UTC 1970-01-01 00:00:00
    Tagged date                              : UTC 1970-01-01 00:00:00
    Writing application                      : Lavf52.64.2

    Video
    ID                                       : 1
    Format                                   : AVC
    Format/Info                              : Advanced Video Codec
    Format profile                           : Baseline@L3.1
    Format settings, CABAC                   : No
    Format settings, ReFrames                : 1 frame
    Format settings, GOP                     : M=1, N=30
    Codec ID                                 : avc1
    Codec ID/Info                            : Advanced Video Coding
    Duration                                 : 7s 9ms
    Bit rate                                 : 3 500 Kbps
    Width                                    : 768 pixels
    Height                                   : 512 pixels
    Display aspect ratio                     : 3:2
    Frame rate mode                          : Variable
    Frame rate                               : 30.250 fps
    Minimum frame rate                       : 23.462 fps
    Maximum frame rate                       : 296.053 fps
    Color space                              : YUV
    Chroma subsampling                       : 4:2:0
    Bit depth                                : 8 bits
    Scan type                                : Progressive
    Bits/(Pixel*Frame)                       : 0.294
    Stream size                              : 2.92 MiB (100%)
    Language                                 : English
    Encoded date                             : UTC 1970-01-01 00:00:00
    Tagged date                              : UTC 1970-01-01 00:00:00

    I’m pretty sure it’s the mp42 vs isom Codec ID’s, and potentially the constant vs variable frame rates. I can’t change the input mp4’s but I know their format will stay the same. How can I reformat the Title and End mp4’s to match the input mp4 files so I can use ffmpeg concat demux ?

  • using libav instead of ffmpeg

    21 janvier 2015, par n00bie

    I want to streaming video over http, i am using ogg(theora + vorbis), now i have sender and receiver, and i can run them using command line :

    Sender :

    ffmpeg -f video4linux2 -s 320x240 -i /dev/mycam -codec:v libtheora -qscale:v 5 -f ogg http://127.0.0.1:8080

    Receiver :

    sudo gst-launch-0.10 tcpserversrc port = 8080 ! oggdemux ! theoradec ! autovideosink

    Now, sender sends both audio and video, but receiver plays only video.

    It works perfect, but now i want not to use ffmpeg and use only libav* instead.

    Here’s my class for streaming :

    class VCORE_LIBRARY_EXPORT VVideoWriter : private boost::noncopyable
    {
    public:
       VVideoWriter( );
       ~VVideoWriter( );

       bool openFile( const std::string& name,
                      int fps, int videoBitrate, int width, int height,
                      int audioSampleRate, bool stereo, int audioBitrate );
       void close( );

       bool writeVideoFrame( const uint8_t* image, int64_t timestamp );
       bool writeAudioFrame( const int16_t* data, int64_t timestamp  );

       int audioFrameSize( ) const;

    private:
       AVFrame *m_videoFrame;
       AVFrame *m_audioFrame;

       AVFormatContext *m_context;
       AVStream *m_videoStream;
       AVStream *m_audioStream;

       int64_t m_startTime;
    };

    Initialization :

    bool VVideoWriter::openFile( const std::string& name,
                                int fps, int videoBitrate, int width, int height,
                                int audioSampleRate, bool stereo, int audioBitrate )
    {
            if( ! m_context )
            {
               // initalize the AV context
               m_context = avformat_alloc_context( );
               assert( m_context );

               // get the output format
               m_context->oformat = av_guess_format( "ogg", name.c_str( ), nullptr );
               if( m_context->oformat )
               {
                   strcpy( m_context->filename, name.c_str( ) );

                   auto codecID = AV_CODEC_ID_THEORA;
                   auto codec = avcodec_find_encoder( codecID );

                   if( codec )
                   {
                       m_videoStream = avformat_new_stream( m_context, codec );
                       assert( m_videoStream );

                       // initalize codec
                       auto codecContext = m_videoStream->codec;
                       bool globalHeader = m_context->oformat->flags & AVFMT_GLOBALHEADER;
                       if( globalHeader )
                           codecContext->flags |= CODEC_FLAG_GLOBAL_HEADER;
                       codecContext->codec_id = codecID;
                       codecContext->codec_type = AVMEDIA_TYPE_VIDEO;
                       codecContext->width = width;
                       codecContext->height = height;
                       codecContext->time_base.den = fps;
                       codecContext->time_base.num = 1;
                       codecContext->bit_rate = videoBitrate;
                       codecContext->pix_fmt = PIX_FMT_YUV420P;
                       codecContext->flags |= CODEC_FLAG_QSCALE;
                       codecContext->global_quality = FF_QP2LAMBDA * 5;

                       int res = avcodec_open2( codecContext, codec, nullptr );

                       if( res >= 0 )
                       {
                           auto codecID = AV_CODEC_ID_VORBIS;
                           auto codec = avcodec_find_encoder( codecID );

                           if( codec )
                           {
                               m_audioStream = avformat_new_stream( m_context, codec );
                               assert( m_audioStream );
                               // initalize codec
                               auto codecContext = m_audioStream->codec;

                               bool globalHeader = m_context->oformat->flags & AVFMT_GLOBALHEADER;
                               if( globalHeader )
                                   codecContext->flags |= CODEC_FLAG_GLOBAL_HEADER;
                               codecContext->codec_id = codecID;
                               codecContext->codec_type = AVMEDIA_TYPE_AUDIO;
                               codecContext->sample_fmt = AV_SAMPLE_FMT_FLTP;
                               codecContext->bit_rate = audioBitrate;
                               codecContext->sample_rate = audioSampleRate;
                               codecContext->channels = stereo ? 2 : 1;
                               codecContext->channel_layout = stereo ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;

                               res = avcodec_open2( codecContext, codec, nullptr );

                               if( res >= 0 )
                               {
                                   // try to open the file
                                   if( avio_open( &m_context->pb, m_context->filename, AVIO_FLAG_WRITE ) >= 0 )
                                   {
                                       m_audioFrame->nb_samples = codecContext->frame_size;
                                       m_audioFrame->format = codecContext->sample_fmt;
                                       m_audioFrame->channel_layout = codecContext->channel_layout;

                                       boost::posix_time::ptime time_t_epoch( boost::gregorian::date( 1970, 1, 1 ) );
                                       m_context->start_time_realtime = ( boost::posix_time::microsec_clock::universal_time( ) - time_t_epoch ).total_microseconds( );
                                       m_startTime = -1;

                                       // write the header
                                       if( avformat_write_header( m_context, nullptr ) >= 0 )
                                       {
                                           return true;
                                       }
                                       else std::cerr << "VVideoWriter: failed to write video header" << std::endl;
                                   }
                                   else std::cerr << "VVideoWriter: failed to open video file " << name << std::endl;
                               }
                               else std::cerr << "VVideoWriter: failed to initialize audio codec" << std::endl;
                           }
                           else std::cerr << "VVideoWriter: requested audio codec is not supported" << std::endl;
                       }
                       else std::cerr << "VVideoWriter: failed to initialize video codec" << std::endl;
                   }
                   else std::cerr << "VVideoWriter: requested video codec is not supported" << std::endl;
               }
               else std::cerr << "VVideoWriter: requested video format is not supported" << std::endl;

               avformat_free_context( m_context );
               m_context = nullptr;
               m_videoStream = nullptr;
               m_audioStream = nullptr;
           }
           return false;
    }

    Writing video :

    bool VVideoWriter::writeVideoFrame( const uint8_t* image, int64_t timestamp )
    {
       if( m_context ) {
           auto codecContext = m_videoStream->codec;
           avpicture_fill( reinterpret_cast( m_videoFrame ),
                           const_cast( image ),
                           codecContext->pix_fmt, codecContext->width, codecContext->height );

           AVPacket pkt;
           av_init_packet( & pkt );
           pkt.data = nullptr;
           pkt.size = 0;
           int gotPacket = 0;
           if( ! avcodec_encode_video2( codecContext, &pkt, m_videoFrame, & gotPacket ) ) {
               if( gotPacket == 1 ) {
                   pkt.stream_index = m_videoStream->index;
                   int res;
                   {
                       pkt.pts = AV_NOPTS_VALUE;
                       pkt.dts = AV_NOPTS_VALUE;
                       pkt.stream_index = m_videoStream->index;
                       res = av_write_frame( m_context, &pkt );
                   }
                   av_free_packet( & pkt );
                   return res >= 0;
               }
               assert( ! pkt.size );
               return true;
           }
       }
       return false;
    }

    Writing audio (now i write test dummy audio) :

    bool VVideoWriter::writeAudioFrame( const int16_t* data, int64_t timestamp )
    {
       if( m_context ) {
           auto codecContext = m_audioStream->codec;

           int buffer_size = av_samples_get_buffer_size(nullptr, codecContext->channels, codecContext->frame_size, codecContext->sample_fmt, 0);

           float *samples = (float*)av_malloc(buffer_size);

           for (int i = 0; i < buffer_size / sizeof(float); i++)
               samples[i] = 1000. * sin((double)i/2.);

           int ret = avcodec_fill_audio_frame( m_audioFrame, codecContext->channels, codecContext->sample_fmt, (const uint8_t*)samples, buffer_size, 0);

           assert( ret >= 0 );
           (void)(ret);

           AVPacket pkt;
           av_init_packet( & pkt );
           pkt.data = nullptr;
           pkt.size = 0;
           int gotPacket = 0;
           if( ! avcodec_encode_audio2( codecContext, &pkt, m_audioFrame, & gotPacket ) ) {
               if( gotPacket == 1 ) {
                   pkt.stream_index = m_audioStream->index;
                   int res;
                   {
                       pkt.pts = AV_NOPTS_VALUE;
                       pkt.dts = AV_NOPTS_VALUE;
                       pkt.stream_index = m_audioStream->index;
                       res = av_write_frame( m_context, &pkt );
                   }
                   av_free_packet( & pkt );
                   return res >= 0;
               }
               assert( ! pkt.size );
               return true;
           }
           return false;
       }
       return false;
    }

    Here’s test example (i send video from webcam and dummy audio) :

    class TestVVideoWriter : public sigslot::has_slots<>
    {
    public:
       TestVVideoWriter( ) :
           m_fileOpened( false )
       {
       }

       void onCapturedFrame( cricket::VideoCapturer*, const cricket::CapturedFrame* capturedFrame )
       {
           if( m_fileOpened ) {
               m_writer.writeVideoFrame( reinterpret_cast<const>( capturedFrame->data ),
                                         capturedFrame->time_stamp / 1000 );
               m_writer.writeAudioFrame( nullptr , 0 );


           } else {
                 m_fileOpened = m_writer.openFile( "http://127.0.0.1:8080",
                                                   15, 40000, capturedFrame->width, capturedFrame->height,
                                                   16000, false, 64000 );
           }
       }

    public:
       vcore::VVideoWriter m_writer;
       bool m_fileOpened;
    };

    TestVVideoWriter testWriter;

    BOOST_AUTO_TEST_SUITE(TEST_VIDEO_WRITER)

    BOOST_AUTO_TEST_CASE(testWritingVideo)
    {
       cricket::LinuxDeviceManager deviceManager;
       std::vector devs;
       if( deviceManager.GetVideoCaptureDevices( &amp;devs ) ) {
           if( devs.size( ) ) {
               boost::shared_ptr camera( deviceManager.CreateVideoCapturer( devs[ 0 ] ) );
               if( camera ) {
                   cricket::VideoFormat format( 320, 240, cricket::VideoFormat::FpsToInterval( 30 ),
                                                camera->GetSupportedFormats( )->front( ).fourcc );
                   cricket::VideoFormat best;
                   if( camera->GetBestCaptureFormat( format, &amp;best ) ) {
                       camera->SignalFrameCaptured.connect( &amp;testWriter, &amp;TestVVideoWriter::onCapturedFrame );
                       if( camera->Start( best ) != cricket::CS_FAILED ) {
                           boost::this_thread::sleep( boost::posix_time::seconds( 10 ) );
                           return;
                       }
                   }
               }
           }
       }
       std::cerr &lt;&lt; "Problem has occured with camera" &lt;&lt; std::endl;
    }

    BOOST_AUTO_TEST_SUITE_END() // TEST_VIDEO_WRITER
    </const>

    But, in this case, gstreamer start playing video only when my test program stop executing (after 10 seconds in this case). It does not suit me, i want gstreamer start playing immediately after starting my test program.

    Could someone help me ?

    P.S. Sorry for my English.

  • ffmpeg : Combine/merge multiple mp4 videos - not working

    9 juin 2016, par dtbaker

    Here is the command I am using to combine multiple videos :

    ffmpeg -i 75_540_38HQ2.mp4 -i 76_70_20.mp4 -i 76_173_80.mp4 -i 81_186_35.mp4 -vcodec copy -acodec copy Mux1.mp4

    The resulting Mux1.mp4 does not contain all videos. Only the first video (75_540_38HQ2.mp4). The file size of the source and resulting video is below (as you can see, resulting video is slightly larger than first vid) :

    $ ls -lh
    
    - rw-r—r— 1 dbaker dbaker 42M 2011-03-24 11:59 75_540_38HQ2.mp4
    - rw-r—r— 1 dbaker dbaker 236M 2011-03-24 12:09 76_173_80.mp4
    - rw-r—r— 1 dbaker dbaker 26M 2011-03-24 12:05 76_70_20.mp4
    - rw-r—r— 1 dbaker dbaker 54M 2011-03-24 12:15 81_186_35.mp4
    - rw-r—r— 1 dbaker dbaker 44M 2011-03-24 14:48 Mux1.mp4

    Here is the output of the ffmpeg command. To me it looks ok, showing the multiple source inputs and the single output.

    FFmpeg version SVN-r26402, Copyright (c) 2000-2011 the FFmpeg developers
      built on Mar 21 2011 18:05:32 with gcc 4.4.5
      configuration : —enable-gpl —enable-version3 —enable-nonfree —enable-postproc —enable-libfaac —enable-libmp3lame —enable-libopencore-amrnb —enable-libopencore-amrwb —enable-libtheora —enable-libvorbis —enable-libvpx —enable-libx264 —enable-libxvid —enable-x11grab
      libavutil     50.36. 0 / 50.36. 0
      libavcore      0.16. 1 /  0.16. 1
      libavcodec    52.108. 0 / 52.108. 0
      libavformat   52.93. 0 / 52.93. 0
      libavdevice   52. 2. 3 / 52. 2. 3
      libavfilter    1.74. 0 /  1.74. 0
      libswscale     0.12. 0 /  0.12. 0
      libpostproc   51. 2. 0 / 51. 2. 0
    Input #0, mov,mp4,m4a,3gp,3g2,mj2, from ’75_540_38HQ2.mp4’ :
      Metadata :
        major_brand : isom
        minor_version : 512
        compatible_brands : isomiso2avc1mp41
        creation_time : 1970-01-01 00:00:00
        encoder : Lavf52.93.0
      Duration : 00:00:29.99, start : 0.000000, bitrate : 11517 kb/s
        Stream #0.0(eng) : Video : h264, yuv420p, 1280x960 [PAR 1:1 DAR 4:3], 11575 kb/s, 29.94 fps, 29.97 tbr, 30k tbn, 59.94 tbc
        Metadata :
          creation_time : 1970-01-01 00:00:00
        Stream #0.1(eng) : Audio : aac, 48000 Hz, stereo, s16, 127 kb/s
        Metadata :
          creation_time : 1970-01-01 00:00:00
    Input #1, mov,mp4,m4a,3gp,3g2,mj2, from ’76_70_20.mp4’ :
      Metadata :
        major_brand : isom
        minor_version : 512
        compatible_brands : isomiso2avc1mp41
        creation_time : 1970-01-01 00:00:00
        encoder : Lavf52.93.0
      Duration : 00:00:19.98, start : 0.000000, bitrate : 10901 kb/s
        Stream #1.0(eng) : Video : h264, yuv420p, 1280x960 [PAR 1:1 DAR 4:3], 10804 kb/s, 29.97 fps, 29.97 tbr, 30k tbn, 59.94 tbc
        Metadata :
          creation_time : 1970-01-01 00:00:00
        Stream #1.1(eng) : Audio : aac, 48000 Hz, stereo, s16, 128 kb/s
        Metadata :
          creation_time : 1970-01-01 00:00:00
    Input #2, mov,mp4,m4a,3gp,3g2,mj2, from ’76_173_80.mp4’ :
      Metadata :
        major_brand : isom
        minor_version : 512
        compatible_brands : isomiso2avc1mp41
        creation_time : 1970-01-01 00:00:00
        encoder : Lavf52.93.0
      Duration : 00:03:09.99, start : 0.000000, bitrate : 10393 kb/s
        Stream #2.0(eng) : Video : h264, yuv420p, 1280x960 [PAR 1:1 DAR 4:3], 10321 kb/s, 29.96 fps, 29.97 tbr, 30k tbn, 59.94 tbc
        Metadata :
          creation_time : 1970-01-01 00:00:00
        Stream #2.1(eng) : Audio : aac, 48000 Hz, stereo, s16, 128 kb/s
        Metadata :
          creation_time : 1970-01-01 00:00:00
    

    Seems stream 0 codec frame rate differs from container frame rate : 119.88 (120000/1001) -> 30000.00 (30000/1)
    Input #3, mov,mp4,m4a,3gp,3g2,mj2, from ’81_186_35.mp4’ :
    Metadata :
    major_brand : isom
    minor_version : 512
    compatible_brands : isomiso2avc1mp41
    creation_time : 1970-01-01 00:00:00
    encoder : Lavf52.93.0
    Duration : 00:00:35.00, start : 0.000000, bitrate : 12700 kb/s
    Stream #3.0(eng) : Video : h264, yuv420p, 1280x720 [PAR 1:1 DAR 16:9], 12620 kb/s, 59.91 fps, 30k tbr, 60k tbn, 119.88 tbc
    Metadata :
    creation_time : 1970-01-01 00:00:00
    Stream #3.1(eng) : Audio : aac, 48000 Hz, stereo, s16, 128 kb/s
    Metadata :
    creation_time : 1970-01-01 00:00:00
    Output #0, mp4, to ’Mux1.mp4’ :
    Metadata :
    major_brand : isom
    minor_version : 512
    compatible_brands : isomiso2avc1mp41
    creation_time : 1970-01-01 00:00:00
    encoder : Lavf52.93.0
    Stream #0.0(eng) : Video : libx264, yuv420p, 1280x960 [PAR 1:1 DAR 4:3], q=2-31, 11575 kb/s, 30k tbn, 29.97 tbc
    Metadata :
    creation_time : 1970-01-01 00:00:00
    Stream #0.1(eng) : Audio : libfaac, 48000 Hz, stereo, 128 kb/s
    Metadata :
    creation_time : 1970-01-01 00:00:00
    Stream mapping :
    Stream #0.0 -> #0.0
    Stream #2.1 -> #0.1
    Press [q] to stop encoding
    frame= 883 fps=632 q=-1.0 Lsize= 44730kB time=29.40 bitrate=12465.1kbits/s
    video:41678kB audio:2969kB global headers:0kB muxing overhead 0.184548%

    Am I doing something blindingly stupid here ?

    The source videos came from a video camera, and are small snippets taken with ffmpeg -i bigfile.mp4 -ss 20 -t 10 -vcodec copy etc..

    Thanks heaps !!
    Dave


    Edit : couldn’t solve it so I just use avidemux GUI tool. It seemed to append the MP4’s just fine.

    Must be a problem with MP4’s or just the ones that come off a gopro camera.