Recherche avancée

Médias (1)

Mot : - Tags -/illustrator

Autres articles (15)

  • Encoding and processing into web-friendly formats

    13 avril 2011, par

    MediaSPIP automatically converts uploaded files to internet-compatible formats.
    Video files are encoded in MP4, Ogv and WebM (supported by HTML5) and MP4 (supported by Flash).
    Audio files are encoded in MP3 and Ogg (supported by HTML5) and MP3 (supported by Flash).
    Where possible, text is analyzed in order to retrieve the data needed for search engine detection, and then exported as a series of image files.
    All uploaded files are stored online in their original format, so you can (...)

  • Keeping control of your media in your hands

    13 avril 2011, par

    The vocabulary used on this site and around MediaSPIP in general, aims to avoid reference to Web 2.0 and the companies that profit from media-sharing.
    While using MediaSPIP, you are invited to avoid using words like "Brand", "Cloud" and "Market".
    MediaSPIP is designed to facilitate the sharing of creative media online, while allowing authors to retain complete control of their work.
    MediaSPIP aims to be accessible to as many people as possible and development is based on expanding the (...)

  • Other interesting software

    13 avril 2011, par

    We don’t claim to be the only ones doing what we do ... and especially not to assert claims to be the best either ... What we do, we just try to do it well and getting better ...
    The following list represents softwares that tend to be more or less as MediaSPIP or that MediaSPIP tries more or less to do the same, whatever ...
    We don’t know them, we didn’t try them, but you can take a peek.
    Videopress
    Website : http://videopress.com/
    License : GNU/GPL v2
    Source code : (...)

Sur d’autres sites (3637)

  • "moov atom not found" when using av_interleaved_write_frame but not avio_write

    9 octobre 2017, par icStatic

    I am attempting to put together a class that can take arbitrary frames and construct a video from it using the ffmpeg 3.3.3 API. I’ve been struggling to find a good example for this as the examples still seem to be using deprecated functions, so I’ve attempted to patch this using the documentation in the headers and by referring to a few github repos that seem to be using the new version.

    If I use av_interleaved_write_frame to write the encoded packets to the output then ffprobe outputs the following :

    [mov,mp4,m4a,3gp,3g2,mj2 @ 0000000002760120] moov atom not found0
    
X:\Diagnostics.mp4: Invalid data found when processing input

    ffplay is unable to play the file generated using this method.

    If I instead swap it out for a call to avio_write, ffprobe instead outputs :

    Input #0, h264, from 'X:\Diagnostics.mp4':
    
  Duration: N/A, bitrate: N/A
    
    Stream #0:0: Video: h264 (Main), yuv420p(progressive), 672x380 [SAR 1:1 DAR 168:95], 25 fps, 25 tbr, 1200k tbn, 50 tbc

    ffplay can mostly play this file until it gets towards the end, when it outputs :

    Input #0, h264, from 'X:\Diagnostics.mp4':    0KB sq=    0B f=0/0
    
  Duration: N/A, bitrate: N/A
    
    Stream #0:0: Video: h264 (Main), yuv420p(progressive), 672x380 [SAR 1:1 DAR 168:95], 25 fps, 25 tbr, 1200k tbn, 50 tbc
    
[h264 @ 000000000254ef80] error while decoding MB 31 22, bytestream -65
    
[h264 @ 000000000254ef80] concealing 102 DC, 102 AC, 102 MV errors in I frame
    
    nan M-V:    nan fd=   1 aq=    0KB vq=    0KB sq=    0B f=0/0

    VLC cannot play files from either method. The second method’s file displays a single black frame then hides the video output. The first does not display anything. Neither of them give a video duration.

    Does anyone have any ideas what’s happening here ? I assume my solution is close to working as I’m getting a good chunk of valid frames coming through.

    Code :

    void main()
    
{
    
    OutputStream Stream( "Output.mp4", 672, 380, 25, true );
    
    Stream.Initialize();
    

    
    int i = 100;
    
    while( i-- )
    
    {
    
        //... Generate a frame
    

    
        Stream.WriteFrame( Frame );
    
    }
    
    Stream.CloseFile();
    
}
    

    
OutputStream::OutputStream( const std::string& Path, unsigned int Width, unsigned int Height, int Framerate, bool IsBGR )
    
: Stream()
    
, FrameIndex( 0 )
    
{
    
    auto& ID = *m_InternalData;
    

    
    ID.Path = Path;
    

    
    ID.Width = Width;
    
    ID.Height= Height;
    
    ID.Framerate.num = Framerate;
    
    ID.Framerate.den = 1;
    

    
    ID.PixelFormat = IsBGR ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_RGB24;
    
    ID.CodecID = AV_CODEC_ID_H264;
    
    ID.CodecTag = 0;
    

    
    ID.AspectRatio.num = 1;
    
    ID.AspectRatio.den = 1;
    
}
    

    
CameraStreamError OutputStream::Initialize()
    
{
    
    av_log_set_callback( &InputStream::LogCallback );
    
    av_register_all();
    
    avformat_network_init();
    

    
    auto& ID = *m_InternalData;
    

    
    av_init_packet( &ID.Packet );
    

    
    int Result = avformat_alloc_output_context2( &ID.FormatContext, nullptr, nullptr, ID.Path.c_str() );
    
    if( Result < 0 || !ID.FormatContext )
    
    {
    
        STREAM_ERROR( UnknownError );
    
    }
    

    
    AVCodec* Encoder = avcodec_find_encoder( ID.CodecID );
    

    
    if( !Encoder )
    
    {
    
        STREAM_ERROR( NoH264Support );
    
    }
    

    
    AVStream* OutStream = avformat_new_stream( ID.FormatContext, Encoder );
    
    if( !OutStream )
    
    {
    
        STREAM_ERROR( UnknownError );
    
    }
    

    
    ID.CodecContext = avcodec_alloc_context3( Encoder );
    
    if( !ID.CodecContext )
    
    {
    
        STREAM_ERROR( NoH264Support );
    
    }
    

    
    ID.CodecContext->time_base = av_inv_q(ID.Framerate);
    

    
    {
    
        AVCodecParameters* CodecParams = OutStream->codecpar;
    

    
        CodecParams->width = ID.Width;
    
        CodecParams->height = ID.Height;
    
        CodecParams->format = AV_PIX_FMT_YUV420P;
    
        CodecParams->codec_id = ID.CodecID;
    
        CodecParams->codec_type = AVMEDIA_TYPE_VIDEO;
    
        CodecParams->profile = FF_PROFILE_H264_MAIN;
    
        CodecParams->level = 40;
    

    
        Result = avcodec_parameters_to_context( ID.CodecContext, CodecParams );
    
        if( Result < 0 )
    
        {
    
            STREAM_ERROR( EncoderCreationError );
    
        }
    
    }
    

    
    if( ID.IsVideo )
    
    {
    
        ID.CodecContext->width = ID.Width;
    
        ID.CodecContext->height = ID.Height;
    
        ID.CodecContext->sample_aspect_ratio = ID.AspectRatio;
    
        ID.CodecContext->time_base = av_inv_q(ID.Framerate);
    

    
        if( Encoder->pix_fmts )
    
        {
    
            ID.CodecContext->pix_fmt = Encoder->pix_fmts[0];
    
        }
    
        else
    
        {
    
            ID.CodecContext->pix_fmt = ID.PixelFormat;
    
        }
    
    }
    
    //Snip
    

    
    Result = avcodec_open2( ID.CodecContext, Encoder, nullptr );
    
    if( Result < 0 )
    
    {
    
        STREAM_ERROR( EncoderCreationError );
    
    }
    

    
    Result = avcodec_parameters_from_context( OutStream->codecpar, ID.CodecContext );
    
    if( Result < 0 )
    
    {
    
        STREAM_ERROR( EncoderCreationError );
    
    }
    

    
    if( ID.FormatContext->oformat->flags & AVFMT_GLOBALHEADER )
    
    {
    
        ID.CodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    
    }
    

    
    OutStream->time_base = ID.CodecContext->time_base;
    
    OutStream->avg_frame_rate= av_inv_q(OutStream->time_base);
    

    
    if( !( ID.FormatContext->oformat->flags & AVFMT_NOFILE ) )
    
    {
    
        Result = avio_open( &ID.FormatContext->pb, ID.Path.c_str(), AVIO_FLAG_WRITE );
    
        if( Result < 0 )
    
        {
    
            STREAM_ERROR( FileNotWriteable );
    
        }
    
    }
    

    
    Result = avformat_write_header( ID.FormatContext, nullptr );
    
    if( Result < 0 )
    
    {
    
        STREAM_ERROR( WriteFailed );
    
    }
    

    
    ID.Output = std::make_unique( ID.CodecContext->width, ID.CodecContext->height, ID.CodecContext->pix_fmt );
    

    
    ID.ConversionContext = sws_getCachedContext(
    
        ID.ConversionContext,
    
        ID.Width,
    
        ID.Height,
    
        ID.PixelFormat,
    
        ID.CodecContext->width,
    
        ID.CodecContext->height,
    
        ID.CodecContext->pix_fmt,
    
        SWS_BICUBIC,
    
        NULL,
    
        NULL,
    
        NULL );
    

    
    return CameraStreamError::Success;
    
}
    

    
CameraStreamError OutputStream::WriteFrame( FFMPEG::Frame* Frame )
    
{
    
    auto& ID = *m_InternalData;
    

    
    ID.Output->Prepare();
    

    
    int OutputSliceSize = sws_scale( m_InternalData->ConversionContext, Frame->GetFrame()->data, Frame->GetFrame()->linesize, 0, Frame->GetHeight(), ID.Output->GetFrame()->data, ID.Output->GetFrame()->linesize );
    

    
    ID.Output->GetFrame()->pts = ID.CodecContext->frame_number;
    

    
    int Result = avcodec_send_frame( GetData().CodecContext, ID.Output->GetFrame() );
    
    if( Result == AVERROR(EAGAIN) )
    
    {
    
        CameraStreamError ResultErr = SendAll();
    
        if( ResultErr != CameraStreamError::Success )
    
        {
    
            return ResultErr;
    
        }
    
        Result = avcodec_send_frame( GetData().CodecContext, ID.Output->GetFrame() );
    
    }
    

    
    if( Result == 0 )
    
    {
    
        CameraStreamError ResultErr = SendAll();
    
        if( ResultErr != CameraStreamError::Success )
    
        {
    
            return ResultErr;
    
        }
    
    }
    

    
    FrameIndex++;
    

    
    return CameraStreamError::Success;
    
}
    

    
CameraStreamError OutputStream::SendAll( void )
    
{
    
    auto& ID = *m_InternalData;
    

    
    int Result;
    
    do 
    
    {
    
        AVPacket TempPacket = {};
    
        av_init_packet( &TempPacket );
    

    
        Result = avcodec_receive_packet( GetData().CodecContext, &TempPacket );
    
        if( Result == 0 )
    
        {
    
            av_packet_rescale_ts( &TempPacket, ID.CodecContext->time_base, ID.FormatContext->streams[0]->time_base );
    

    
            TempPacket.stream_index = ID.FormatContext->streams[0]->index;
    

    
            //avio_write( ID.FormatContext->pb, TempPacket.data, TempPacket.size );
    
            Result = av_interleaved_write_frame( ID.FormatContext, &TempPacket );
    
            if( Result < 0 )
    
            {
    
                STREAM_ERROR( WriteFailed );
    
            }
    

    
            av_packet_unref( &TempPacket );
    
        }
    
        else if( Result != AVERROR(EAGAIN) )
    
        {
    
            continue;
    
        }
    
        else if( Result != AVERROR_EOF )
    
        {
    
            break;
    
        }
    
        else if( Result < 0 )
    
        {
    
            STREAM_ERROR( WriteFailed );
    
        }
    
    } while ( Result == 0);
    

    
    return CameraStreamError::Success;
    
}
    

    
CameraStreamError OutputStream::CloseFile()
    
{
    
    auto& ID = *m_InternalData;
    

    
    while( true )
    
    {
    
        //Flush
    
        int Result = avcodec_send_frame( ID.CodecContext, nullptr );
    
        if( Result == 0 )
    
        {
    
            CameraStreamError StrError = SendAll();
    
            if( StrError != CameraStreamError::Success )
    
            {
    
                return StrError;
    
            }
    
        }
    
        else if( Result == AVERROR_EOF )
    
        {
    
            break;
    
        }
    
        else
    
        {
    
            STREAM_ERROR( WriteFailed );
    
        }
    
    }
    

    
    int Result = av_write_trailer( ID.FormatContext );
    
    if( Result < 0 )
    
    {
    
        STREAM_ERROR( WriteFailed );
    
    }
    

    
    if( !(ID.FormatContext->oformat->flags& AVFMT_NOFILE) )
    
    {
    
        Result = avio_close( ID.FormatContext->pb );
    
        if( Result < 0 )
    
        {
    
            STREAM_ERROR( WriteFailed );
    
        }
    
    }
    

    
    return CameraStreamError::Success;
    
}

    Note I’ve simplified a few things and inlined a few bits that were elsewhere. I’ve also removed all the shutdown code as anything that happens after the file is closed is irrelevant.

    Full repo here : https://github.com/IanNorris/Witness If you clone this the issue is with the ’Diagnostics’ output, the Output file is fine. There are two hardcoded paths to X :.

  • "moov atom not found" when using av_interleaved_write_frame but not avio_write

    9 octobre 2017, par icStatic

    I am attempting to put together a class that can take arbitrary frames and construct a video from it using the ffmpeg 3.3.3 API. I’ve been struggling to find a good example for this as the examples still seem to be using deprecated functions, so I’ve attempted to patch this using the documentation in the headers and by referring to a few github repos that seem to be using the new version.

    If I use av_interleaved_write_frame to write the encoded packets to the output then ffprobe outputs the following :

    [mov,mp4,m4a,3gp,3g2,mj2 @ 0000000002760120] moov atom not found0
    
X:\Diagnostics.mp4: Invalid data found when processing input

    ffplay is unable to play the file generated using this method.

    If I instead swap it out for a call to avio_write, ffprobe instead outputs :

    Input #0, h264, from 'X:\Diagnostics.mp4':
    
  Duration: N/A, bitrate: N/A
    
    Stream #0:0: Video: h264 (Main), yuv420p(progressive), 672x380 [SAR 1:1 DAR 168:95], 25 fps, 25 tbr, 1200k tbn, 50 tbc

    ffplay can mostly play this file until it gets towards the end, when it outputs :

    Input #0, h264, from 'X:\Diagnostics.mp4':    0KB sq=    0B f=0/0
    
  Duration: N/A, bitrate: N/A
    
    Stream #0:0: Video: h264 (Main), yuv420p(progressive), 672x380 [SAR 1:1 DAR 168:95], 25 fps, 25 tbr, 1200k tbn, 50 tbc
    
[h264 @ 000000000254ef80] error while decoding MB 31 22, bytestream -65
    
[h264 @ 000000000254ef80] concealing 102 DC, 102 AC, 102 MV errors in I frame
    
    nan M-V:    nan fd=   1 aq=    0KB vq=    0KB sq=    0B f=0/0

    VLC cannot play files from either method. The second method’s file displays a single black frame then hides the video output. The first does not display anything. Neither of them give a video duration.

    Does anyone have any ideas what’s happening here ? I assume my solution is close to working as I’m getting a good chunk of valid frames coming through.

    Code :

    void main()
    
{
    
    OutputStream Stream( "Output.mp4", 672, 380, 25, true );
    
    Stream.Initialize();
    

    
    int i = 100;
    
    while( i-- )
    
    {
    
        //... Generate a frame
    

    
        Stream.WriteFrame( Frame );
    
    }
    
    Stream.CloseFile();
    
}
    

    
OutputStream::OutputStream( const std::string& Path, unsigned int Width, unsigned int Height, int Framerate, bool IsBGR )
    
: Stream()
    
, FrameIndex( 0 )
    
{
    
    auto& ID = *m_InternalData;
    

    
    ID.Path = Path;
    

    
    ID.Width = Width;
    
    ID.Height= Height;
    
    ID.Framerate.num = Framerate;
    
    ID.Framerate.den = 1;
    

    
    ID.PixelFormat = IsBGR ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_RGB24;
    
    ID.CodecID = AV_CODEC_ID_H264;
    
    ID.CodecTag = 0;
    

    
    ID.AspectRatio.num = 1;
    
    ID.AspectRatio.den = 1;
    
}
    

    
CameraStreamError OutputStream::Initialize()
    
{
    
    av_log_set_callback( &InputStream::LogCallback );
    
    av_register_all();
    
    avformat_network_init();
    

    
    auto& ID = *m_InternalData;
    

    
    av_init_packet( &ID.Packet );
    

    
    int Result = avformat_alloc_output_context2( &ID.FormatContext, nullptr, nullptr, ID.Path.c_str() );
    
    if( Result < 0 || !ID.FormatContext )
    
    {
    
        STREAM_ERROR( UnknownError );
    
    }
    

    
    AVCodec* Encoder = avcodec_find_encoder( ID.CodecID );
    

    
    if( !Encoder )
    
    {
    
        STREAM_ERROR( NoH264Support );
    
    }
    

    
    AVStream* OutStream = avformat_new_stream( ID.FormatContext, Encoder );
    
    if( !OutStream )
    
    {
    
        STREAM_ERROR( UnknownError );
    
    }
    

    
    ID.CodecContext = avcodec_alloc_context3( Encoder );
    
    if( !ID.CodecContext )
    
    {
    
        STREAM_ERROR( NoH264Support );
    
    }
    

    
    ID.CodecContext->time_base = av_inv_q(ID.Framerate);
    

    
    {
    
        AVCodecParameters* CodecParams = OutStream->codecpar;
    

    
        CodecParams->width = ID.Width;
    
        CodecParams->height = ID.Height;
    
        CodecParams->format = AV_PIX_FMT_YUV420P;
    
        CodecParams->codec_id = ID.CodecID;
    
        CodecParams->codec_type = AVMEDIA_TYPE_VIDEO;
    
        CodecParams->profile = FF_PROFILE_H264_MAIN;
    
        CodecParams->level = 40;
    

    
        Result = avcodec_parameters_to_context( ID.CodecContext, CodecParams );
    
        if( Result < 0 )
    
        {
    
            STREAM_ERROR( EncoderCreationError );
    
        }
    
    }
    

    
    if( ID.IsVideo )
    
    {
    
        ID.CodecContext->width = ID.Width;
    
        ID.CodecContext->height = ID.Height;
    
        ID.CodecContext->sample_aspect_ratio = ID.AspectRatio;
    
        ID.CodecContext->time_base = av_inv_q(ID.Framerate);
    

    
        if( Encoder->pix_fmts )
    
        {
    
            ID.CodecContext->pix_fmt = Encoder->pix_fmts[0];
    
        }
    
        else
    
        {
    
            ID.CodecContext->pix_fmt = ID.PixelFormat;
    
        }
    
    }
    
    //Snip
    

    
    Result = avcodec_open2( ID.CodecContext, Encoder, nullptr );
    
    if( Result < 0 )
    
    {
    
        STREAM_ERROR( EncoderCreationError );
    
    }
    

    
    Result = avcodec_parameters_from_context( OutStream->codecpar, ID.CodecContext );
    
    if( Result < 0 )
    
    {
    
        STREAM_ERROR( EncoderCreationError );
    
    }
    

    
    if( ID.FormatContext->oformat->flags & AVFMT_GLOBALHEADER )
    
    {
    
        ID.CodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    
    }
    

    
    OutStream->time_base = ID.CodecContext->time_base;
    
    OutStream->avg_frame_rate= av_inv_q(OutStream->time_base);
    

    
    if( !( ID.FormatContext->oformat->flags & AVFMT_NOFILE ) )
    
    {
    
        Result = avio_open( &ID.FormatContext->pb, ID.Path.c_str(), AVIO_FLAG_WRITE );
    
        if( Result < 0 )
    
        {
    
            STREAM_ERROR( FileNotWriteable );
    
        }
    
    }
    

    
    Result = avformat_write_header( ID.FormatContext, nullptr );
    
    if( Result < 0 )
    
    {
    
        STREAM_ERROR( WriteFailed );
    
    }
    

    
    ID.Output = std::make_unique( ID.CodecContext->width, ID.CodecContext->height, ID.CodecContext->pix_fmt );
    

    
    ID.ConversionContext = sws_getCachedContext(
    
        ID.ConversionContext,
    
        ID.Width,
    
        ID.Height,
    
        ID.PixelFormat,
    
        ID.CodecContext->width,
    
        ID.CodecContext->height,
    
        ID.CodecContext->pix_fmt,
    
        SWS_BICUBIC,
    
        NULL,
    
        NULL,
    
        NULL );
    

    
    return CameraStreamError::Success;
    
}
    

    
CameraStreamError OutputStream::WriteFrame( FFMPEG::Frame* Frame )
    
{
    
    auto& ID = *m_InternalData;
    

    
    ID.Output->Prepare();
    

    
    int OutputSliceSize = sws_scale( m_InternalData->ConversionContext, Frame->GetFrame()->data, Frame->GetFrame()->linesize, 0, Frame->GetHeight(), ID.Output->GetFrame()->data, ID.Output->GetFrame()->linesize );
    

    
    ID.Output->GetFrame()->pts = ID.CodecContext->frame_number;
    

    
    int Result = avcodec_send_frame( GetData().CodecContext, ID.Output->GetFrame() );
    
    if( Result == AVERROR(EAGAIN) )
    
    {
    
        CameraStreamError ResultErr = SendAll();
    
        if( ResultErr != CameraStreamError::Success )
    
        {
    
            return ResultErr;
    
        }
    
        Result = avcodec_send_frame( GetData().CodecContext, ID.Output->GetFrame() );
    
    }
    

    
    if( Result == 0 )
    
    {
    
        CameraStreamError ResultErr = SendAll();
    
        if( ResultErr != CameraStreamError::Success )
    
        {
    
            return ResultErr;
    
        }
    
    }
    

    
    FrameIndex++;
    

    
    return CameraStreamError::Success;
    
}
    

    
CameraStreamError OutputStream::SendAll( void )
    
{
    
    auto& ID = *m_InternalData;
    

    
    int Result;
    
    do 
    
    {
    
        AVPacket TempPacket = {};
    
        av_init_packet( &TempPacket );
    

    
        Result = avcodec_receive_packet( GetData().CodecContext, &TempPacket );
    
        if( Result == 0 )
    
        {
    
            av_packet_rescale_ts( &TempPacket, ID.CodecContext->time_base, ID.FormatContext->streams[0]->time_base );
    

    
            TempPacket.stream_index = ID.FormatContext->streams[0]->index;
    

    
            //avio_write( ID.FormatContext->pb, TempPacket.data, TempPacket.size );
    
            Result = av_interleaved_write_frame( ID.FormatContext, &TempPacket );
    
            if( Result < 0 )
    
            {
    
                STREAM_ERROR( WriteFailed );
    
            }
    

    
            av_packet_unref( &TempPacket );
    
        }
    
        else if( Result != AVERROR(EAGAIN) )
    
        {
    
            continue;
    
        }
    
        else if( Result != AVERROR_EOF )
    
        {
    
            break;
    
        }
    
        else if( Result < 0 )
    
        {
    
            STREAM_ERROR( WriteFailed );
    
        }
    
    } while ( Result == 0);
    

    
    return CameraStreamError::Success;
    
}
    

    
CameraStreamError OutputStream::CloseFile()
    
{
    
    auto& ID = *m_InternalData;
    

    
    while( true )
    
    {
    
        //Flush
    
        int Result = avcodec_send_frame( ID.CodecContext, nullptr );
    
        if( Result == 0 )
    
        {
    
            CameraStreamError StrError = SendAll();
    
            if( StrError != CameraStreamError::Success )
    
            {
    
                return StrError;
    
            }
    
        }
    
        else if( Result == AVERROR_EOF )
    
        {
    
            break;
    
        }
    
        else
    
        {
    
            STREAM_ERROR( WriteFailed );
    
        }
    
    }
    

    
    int Result = av_write_trailer( ID.FormatContext );
    
    if( Result < 0 )
    
    {
    
        STREAM_ERROR( WriteFailed );
    
    }
    

    
    if( !(ID.FormatContext->oformat->flags& AVFMT_NOFILE) )
    
    {
    
        Result = avio_close( ID.FormatContext->pb );
    
        if( Result < 0 )
    
        {
    
            STREAM_ERROR( WriteFailed );
    
        }
    
    }
    

    
    return CameraStreamError::Success;
    
}

    Note I’ve simplified a few things and inlined a few bits that were elsewhere. I’ve also removed all the shutdown code as anything that happens after the file is closed is irrelevant.

    Full repo here : https://github.com/IanNorris/Witness If you clone this the issue is with the ’Diagnostics’ output, the Output file is fine. There are two hardcoded paths to X :.

  • FFmpeg "movflags" > "faststart" causes av_write_trailer() to return -2

    30 juin 2016, par williamtroup

    I’m setting up the format layout for the ideo as follows :

    AVOutputFormat* outputFormat = ffmpeg.av_guess_format(null, "output.mp4", null);
    

    
AVCodec* videoCodec = ffmpeg.avcodec_find_encoder(outputFormat->video_codec);
    

    
AVFormatContext* formatContext = ffmpeg.avformat_alloc_context();
    
formatContext->oformat = outputFormat;
    
formatContext->video_codec_id = videoCodec->id;
    

    
ffmpeg.avformat_new_stream(formatContext, videoCodec);

    This is how I am setting up the Codec Context :

    AVCodecContext* codecContext = ffmpeg.avcodec_alloc_context3(videoCodec);
    
codecContext->bit_rate = 400000;
    
codecContext->width = 1280;
    
codecContext->height = 720;
    
codecContext->gop_size = 12;
    
codecContext->max_b_frames = 1;
    
codecContext->pix_fmt = videoCodec->pix_fmts[0];
    
codecContext->codec_id = videoCodec->id;
    
codecContext->codec_type = videoCodec->type;
    
codecContext->time_base = new AVRational
    
{
    
    num = 1,
    
    den = 30
    
};

    I’m using the following code to setup the "movflags" > "faststart" option for the header of the video :

    AVDictionary* options = null;
    

    
int result = ffmpeg.av_dict_set(&options, "movflags", "faststart", 0);
    

    
int writeHeaderResult = ffmpeg.avformat_write_header(formatContext, &options);

    The file is opened and the header is written as follows :

    if ((formatContext->oformat->flags & ffmpeg.AVFMT_NOFILE) == 0)
    
{
    
    int ioOptionResult = ffmpeg.avio_open(&formatContext->pb, "output.mp4", ffmpeg.AVIO_FLAG_WRITE);
    
}
    

    
int writeHeaderResult = ffmpeg.avformat_write_header(formatContext, &options);

    After this, I write each video frame as follows :

    outputFrame->pts = frameIndex;
    

    
packet.flags |= ffmpeg.AV_PKT_FLAG_KEY;
    
packet.pts = frameIndex;
    
packet.dts = frameIndex;
    

    
int encodedFrame = 0;
    
int encodeVideoResult = ffmpeg.avcodec_encode_video2(codecContext, &packet, outputFrame, &encodedFrame);
    

    
if (encodedFrame != 0)
    
{
    
    packet.pts = ffmpeg.av_rescale_q(packet.pts, codecContext->time_base, m_videoStream->time_base);
    
    packet.dts = ffmpeg.av_rescale_q(packet.dts, codecContext->time_base, m_videoStream->time_base);
    
    packet.stream_index = m_videoStream->index;
    

    
    if (codecContext->coded_frame->key_frame > 0)
    
    {
    
        packet.flags |= ffmpeg.AV_PKT_FLAG_KEY;
    
    }
    

    
    int writeFrameResult = ffmpeg.av_interleaved_write_frame(formatContext, &packet);
    
}

    After that, I write the trailer :

    int writeTrailerResult = ffmpeg.av_write_trailer(formatContext);

    However, writeTrailerResult is always -2. I’m been looking into this problem for days and cannot figure out what the problem is.

    The DLLs used for the AutoGen library are :

    avcodec-56.dll
    
avdevice-56.dll
    
avfilter-5.dll
    
avformat-56.dll
    
avutil-54.dll
    
postproc-53.dll
    
swresample-1.dll
    
swscale-3.dll

Navigation