Recherche avancée

Médias (1)

Mot : - Tags -/belgique

Autres articles (16)

  • 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 (...)

  • Qu’est ce qu’un éditorial

    21 juin 2013, par

    Ecrivez votre de point de vue dans un article. Celui-ci sera rangé dans une rubrique prévue à cet effet.
    Un éditorial est un article de type texte uniquement. Il a pour objectif de ranger les points de vue dans une rubrique dédiée. Un seul éditorial est placé à la une en page d’accueil. Pour consulter les précédents, consultez la rubrique dédiée.
    Vous pouvez personnaliser le formulaire de création d’un éditorial.
    Formulaire de création d’un éditorial Dans le cas d’un document de type éditorial, les (...)

  • 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 (...)

Sur d’autres sites (2971)

  • Video creation with a recent ffmpeg API (2017)

    16 novembre 2017, par ar2015

    I have started learning how to work with ffmpeg which has a suffering deprecation of all tutorial and available examples such as this.

    I am looking for a code which creates an output video.

    Unfortunately, most of good examples are focusing on reading from a file rather than creating one.

    Here, I have found a deprecated example and I spent a long time to fix its errors until it became like this :

    #include <iostream>
    
#include 
    
#include 
    
#include <string>
    

    
extern "C" {
    
        #include <libavcodec></libavcodec>avcodec.h>
    
        #include <libavformat></libavformat>avformat.h>
    
        #include <libswscale></libswscale>swscale.h>
    
        #include <libavformat></libavformat>avio.h>
    
        #include <libavutil></libavutil>opt.h>
    
}
    

    
#define WIDTH 800
    
#define HEIGHT 480
    
#define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * FRAME_RATE))
    
#define FRAME_RATE 24
    
#define PIXEL_FORMAT AV_PIX_FMT_YUV420P
    
#define STREAM_DURATION 5.0 //seconds
    
#define BIT_RATE 400000
    

    
#define AV_CODEC_FLAG_GLOBAL_HEADER (1 &lt;&lt; 22)
    
#define CODEC_FLAG_GLOBAL_HEADER AV_CODEC_FLAG_GLOBAL_HEADER
    
#define AVFMT_RAWPICTURE 0x0020
    

    
using namespace std;
    

    
static int sws_flags = SWS_BICUBIC;
    

    
AVFrame *picture, *tmp_picture;
    
uint8_t *video_outbuf;
    
int frame_count, video_outbuf_size;
    

    

    
/****** IF LINUX ******/
    
inline int sprintf_s(char* buffer, size_t sizeOfBuffer, const char* format, ...)
    
{
    
    va_list ap;
    
    va_start(ap, format);
    
    int result = vsnprintf(buffer, sizeOfBuffer, format, ap);
    
    va_end(ap);
    
    return result;
    
}
    

    
/****** IF LINUX ******/
    
template
    
inline int sprintf_s(char (&amp;buffer)[sizeOfBuffer], const char* format, ...)
    
{
    
    va_list ap;
    
    va_start(ap, format);
    
    int result = vsnprintf(buffer, sizeOfBuffer, format, ap);
    
    va_end(ap);
    
    return result;
    
}
    

    

    
static void closeVideo(AVFormatContext *oc, AVStream *st)
    
{
    
    avcodec_close(st->codec);
    
    av_free(picture->data[0]);
    
    av_free(picture);
    
    if (tmp_picture)
    
    {
    
        av_free(tmp_picture->data[0]);
    
        av_free(tmp_picture);
    
    }
    
    av_free(video_outbuf);
    
}
    

    
static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)
    
{
    
    AVFrame *picture;
    
    uint8_t *picture_buf;
    
    int size;
    

    
    picture = av_frame_alloc();
    
    if(!picture)
    
        return NULL;
    
    size = avpicture_get_size(pix_fmt, width, height);
    
    picture_buf = (uint8_t*)(av_malloc(size));
    
    if (!picture_buf)
    
    {
    
        av_free(picture);
    
        return NULL;
    
    }
    
    avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, WIDTH, HEIGHT);
    
    return picture;
    
}
    

    
static void openVideo(AVFormatContext *oc, AVStream *st)
    
{
    
    AVCodec *codec;
    
    AVCodecContext *c;
    

    
    c = st->codec;
    
    if(c->idct_algo == AV_CODEC_ID_H264)
    
        av_opt_set(c->priv_data, "preset", "slow", 0);
    

    
    codec = avcodec_find_encoder(c->codec_id);
    
    if(!codec)
    
    {
    
        std::cout &lt;&lt; "Codec not found." &lt;&lt; std::endl;
    
        std::cin.get();std::cin.get();exit(1);
    
    }
    

    
    if(codec->id == AV_CODEC_ID_H264)
    
        av_opt_set(c->priv_data, "preset", "medium", 0);
    

    
    if(avcodec_open2(c, codec, NULL) &lt; 0)
    
    {
    
        std::cout &lt;&lt; "Could not open codec." &lt;&lt; std::endl;
    
        std::cin.get();std::cin.get();exit(1);
    
    }
    
    video_outbuf = NULL;
    
    if(!(oc->oformat->flags &amp; AVFMT_RAWPICTURE))
    
    {
    
        video_outbuf_size = 200000;
    
        video_outbuf = (uint8_t*)(av_malloc(video_outbuf_size));
    
    }
    
    picture = alloc_picture(c->pix_fmt, c->width, c->height);
    
    if(!picture)
    
    {
    
        std::cout &lt;&lt; "Could not allocate picture" &lt;&lt; std::endl;
    
        std::cin.get();exit(1);
    
    }
    
    tmp_picture = NULL;
    
    if(c->pix_fmt != AV_PIX_FMT_YUV420P)
    
    {
    
        tmp_picture = alloc_picture(AV_PIX_FMT_YUV420P, WIDTH, HEIGHT);
    
        if(!tmp_picture)
    
        {
    
            std::cout &lt;&lt; " Could not allocate temporary picture" &lt;&lt; std::endl;
    
            std::cin.get();exit(1);
    
        }
    
    }
    
}
    

    

    
static AVStream* addVideoStream(AVFormatContext *context, enum AVCodecID codecID)
    
{
    
    AVCodecContext *codec;
    
    AVStream *stream;
    
    stream = avformat_new_stream(context, NULL);
    
    if(!stream)
    
    {
    
        std::cout &lt;&lt; "Could not alloc stream." &lt;&lt; std::endl;
    
        std::cin.get();exit(1);
    
    }
    

    
    codec = stream->codec;
    
    codec->codec_id = codecID;
    
    codec->codec_type = AVMEDIA_TYPE_VIDEO;
    

    
    // sample rate
    
    codec->bit_rate = BIT_RATE;
    
    // resolution must be a multiple of two
    
    codec->width = WIDTH;
    
    codec->height = HEIGHT;
    
    codec->time_base.den = FRAME_RATE; // stream fps
    
    codec->time_base.num = 1;
    
    codec->gop_size = 12; // intra frame every twelve frames at most
    
    codec->pix_fmt = PIXEL_FORMAT;
    
    if(codec->codec_id == AV_CODEC_ID_MPEG2VIDEO)
    
        codec->max_b_frames = 2; // for testing, B frames
    

    
    if(codec->codec_id == AV_CODEC_ID_MPEG1VIDEO)
    
        codec->mb_decision = 2;
    

    
    if(context->oformat->flags &amp; AVFMT_GLOBALHEADER)
    
        codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    

    
    return stream;
    
}
    

    
static void fill_yuv_image(AVFrame *pict, int frame_index, int width, int height)
    
{
    
    int x, y, i;
    
    i = frame_index;
    

    
    /* Y */
    
    for(y=0;ydata[0][y * pict->linesize[0] + x] = x + y + i * 3;
    
        }
    
    }
    

    
    /* Cb and Cr */
    
    for(y=0;y<height></height>2;y++) {
    
        for(x=0;x<width></width>2;x++) {
    
            pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
    
            pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
    
        }
    
    }
    
}
    

    
static void write_video_frame(AVFormatContext *oc, AVStream *st)
    
{
    
    int out_size, ret;
    
    AVCodecContext *c;
    
    static struct SwsContext *img_convert_ctx;
    
    c = st->codec;
    

    
    if(frame_count >= STREAM_NB_FRAMES)
    
    {
    

    
    }
    
    else
    
    {
    
        if(c->pix_fmt != AV_PIX_FMT_YUV420P)
    
        {
    
            if(img_convert_ctx = NULL)
    
            {
    
                img_convert_ctx = sws_getContext(WIDTH, HEIGHT, AV_PIX_FMT_YUV420P, WIDTH, HEIGHT,
    
                                                c->pix_fmt, sws_flags, NULL, NULL, NULL);
    
                if(img_convert_ctx == NULL)
    
                {
    
                    std::cout &lt;&lt; "Cannot initialize the conversion context" &lt;&lt; std::endl;
    
                    std::cin.get();exit(1);
    
                }
    
            }
    
            fill_yuv_image(tmp_picture, frame_count, WIDTH, HEIGHT);
    
            sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize, 0, HEIGHT,
    
                        picture->data, picture->linesize);
    
        }
    
        else
    
        {
    
            fill_yuv_image(picture, frame_count, WIDTH, HEIGHT);
    
        }
    
    }
    

    
    if (oc->oformat->flags &amp; AVFMT_RAWPICTURE)
    
    {
    
        /* raw video case. The API will change slightly in the near
    
           futur for that */
    
        AVPacket pkt;
    
        av_init_packet(&amp;pkt);
    

    
        pkt.flags |= AV_PKT_FLAG_KEY;
    
        pkt.stream_index= st->index;
    
        pkt.data= (uint8_t *)picture;
    
        pkt.size= sizeof(AVPicture);
    

    
        ret = av_interleaved_write_frame(oc, &amp;pkt);
    
    }
    
    else
    
    {
    
        /* encode the image */
    
        out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
    
        /* if zero size, it means the image was buffered */
    
        if (out_size > 0)
    
        {
    
            AVPacket pkt;
    
            av_init_packet(&amp;pkt);
    

    
            if (c->coded_frame->pts != AV_NOPTS_VALUE)
    
                pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
    
            if(c->coded_frame->key_frame)
    
                pkt.flags |= AV_PKT_FLAG_KEY;
    
            pkt.stream_index= st->index;
    
            pkt.data= video_outbuf;
    
            pkt.size= out_size;
    
            /* write the compressed frame in the media file */
    
            ret = av_interleaved_write_frame(oc, &amp;pkt);
    
        } else {
    
            ret = 0;
    
        }
    
    }
    
    if (ret != 0) {
    
        std::cout &lt;&lt; "Error while writing video frames" &lt;&lt; std::endl;
    
        std::cin.get();exit(1);
    
    }
    
    frame_count++;
    
}
    

    
int main ( int argc, char *argv[] )
    
{
    
    const char* filename = "test.h264";
    
    AVOutputFormat *outputFormat;
    
    AVFormatContext *context;
    
    AVCodecContext *codec;
    
    AVStream *videoStream;
    
    double videoPTS;
    

    
    // init libavcodec, register all codecs and formats
    
    av_register_all(); 
    
    // auto detect the output format from the name
    
    outputFormat = av_guess_format(NULL, filename, NULL);
    
    if(!outputFormat)
    
    {
    
        std::cout &lt;&lt; "Cannot guess output format! Using mpeg!" &lt;&lt; std::endl;
    
        std::cin.get();
    
        outputFormat = av_guess_format(NULL, "h263" , NULL);
    
    }
    
    if(!outputFormat)
    
    {
    
        std::cout &lt;&lt; "Could not find suitable output format." &lt;&lt; std::endl;
    
        std::cin.get();exit(1);
    
    }
    

    
    context = avformat_alloc_context();
    
    if(!context)
    
    {
    
        std::cout &lt;&lt; "Cannot allocate avformat memory." &lt;&lt; std::endl;
    
        std::cin.get();exit(1);
    
    }
    
    context->oformat = outputFormat;
    
    sprintf_s(context->filename, sizeof(context->filename), "%s", filename);
    
    std::cout &lt;&lt; "Is '" &lt;&lt; context->filename &lt;&lt; "' = '" &lt;&lt; filename &lt;&lt; "'" &lt;&lt; std::endl;
    

    

    
    videoStream = NULL;
    
    outputFormat->audio_codec = AV_CODEC_ID_NONE;
    
    videoStream = addVideoStream(context, outputFormat->video_codec);
    

    
    /* still needed?
    
    if(av_set_parameters(context, NULL) &lt; 0)
    
    {
    
        std::cout &lt;&lt; "Invalid output format parameters." &lt;&lt; std::endl;
    
        exit(0);
    
    }*/
    

    
    av_dump_format(context, 0, filename, 1);
    

    
    if(videoStream)
    
        openVideo(context, videoStream);
    

    
    if(!outputFormat->flags &amp; AVFMT_NOFILE)
    
    {
    
        if(avio_open(&amp;context->pb, filename, AVIO_FLAG_READ_WRITE) &lt; 0)
    
        {
    
            std::cout &lt;&lt; "Could not open " &lt;&lt; filename &lt;&lt; std::endl;
    
            std::cin.get();exit(1);
    
        }
    
    }
    

    
    avformat_write_header(context, 0);
    

    
    while(true)
    
    {
    
        if(videoStream)
    
            videoPTS = (double) videoStream->pts.val * videoStream->time_base.num / videoStream->time_base.den;
    
        else
    
            videoPTS = 0.;
    

    
        if((!videoStream || videoPTS >= STREAM_DURATION))
    
        {
    
            break;
    
        }
    
        write_video_frame(context, videoStream);
    
    }
    
    av_write_trailer(context);
    
    if(videoStream)
    
        closeVideo(context, videoStream);
    
    for(int i = 0; i &lt; context->nb_streams; i++)
    
    {
    
        av_freep(&amp;context->streams[i]->codec);
    
        av_freep(&amp;context->streams[i]);
    
    }
    

    
    if(!(outputFormat->flags &amp; AVFMT_NOFILE))
    
    {
    
        avio_close(context->pb);
    
    }
    
    av_free(context);
    
    std::cin.get();
    
    return 0;
    
}
    
</string></iostream>

    Compile :

    g++ -I ./FFmpeg/ video.cpp -L fflibs -lavcodec -lavformat

    The code comes with two errors :

    video.cpp:249:84: error: ‘avcodec_encode_video’ was not declared in this scope
    
         out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
    
                                                                                    ^
    

    

    
video.cpp: In function ‘int main(int, char**)’:
    
video.cpp:342:46: error: ‘AVStream {aka struct AVStream}’ has no member named ‘pts’
    
             videoPTS = (double) videoStream->pts.val * videoStream->time_base.num / videoStream->time_base.den;
    
                                              ^

    and a huge number of warnings for deprecation.

    video.cpp: In function ‘void closeVideo(AVFormatContext*, AVStream*)’:
    
video.cpp:60:23: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     avcodec_close(st->codec);
    
                       ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:60:23: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     avcodec_close(st->codec);
    
                       ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:60:23: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     avcodec_close(st->codec);
    
                       ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp: In function ‘AVFrame* alloc_picture(AVPixelFormat, int, int)’:
    
video.cpp:80:12: warning: ‘int avpicture_get_size(AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
    
     size = avpicture_get_size(pix_fmt, width, height);
    
            ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:5228:5: note: declared here
    
 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
    
     ^
    
video.cpp:80:12: warning: ‘int avpicture_get_size(AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
    
     size = avpicture_get_size(pix_fmt, width, height);
    
            ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:5228:5: note: declared here
    
 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
    
     ^
    
video.cpp:80:53: warning: ‘int avpicture_get_size(AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
    
     size = avpicture_get_size(pix_fmt, width, height);
    
                                                     ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:5228:5: note: declared here
    
 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
    
     ^
    
video.cpp:87:5: warning: ‘int avpicture_fill(AVPicture*, const uint8_t*, AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
    
     avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, WIDTH, HEIGHT);
    
     ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:5213:5: note: declared here
    
 int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
    
     ^
    
video.cpp:87:5: warning: ‘int avpicture_fill(AVPicture*, const uint8_t*, AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
    
     avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, WIDTH, HEIGHT);
    
     ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:5213:5: note: declared here
    
 int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
    
     ^
    
video.cpp:87:78: warning: ‘int avpicture_fill(AVPicture*, const uint8_t*, AVPixelFormat, int, int)’ is deprecated [-Wdeprecated-declarations]
    
     avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, WIDTH, HEIGHT);
    
                                                                              ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:5213:5: note: declared here
    
 int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
    
     ^
    
video.cpp: In function ‘void openVideo(AVFormatContext*, AVStream*)’:
    
video.cpp:96:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     c = st->codec;
    
             ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:96:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     c = st->codec;
    
             ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:96:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     c = st->codec;
    
             ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp: In function ‘AVStream* addVideoStream(AVFormatContext*, AVCodecID)’:
    
video.cpp:151:21: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     codec = stream->codec;
    
                     ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:151:21: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     codec = stream->codec;
    
                     ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:151:21: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     codec = stream->codec;
    
                     ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp: In function ‘void write_video_frame(AVFormatContext*, AVStream*)’:
    
video.cpp:202:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     c = st->codec;
    
             ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:202:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     c = st->codec;
    
             ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:202:13: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
     c = st->codec;
    
             ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:256:20: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
             if (c->coded_frame->pts != AV_NOPTS_VALUE)
    
                    ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:256:20: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
             if (c->coded_frame->pts != AV_NOPTS_VALUE)
    
                    ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:256:20: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
             if (c->coded_frame->pts != AV_NOPTS_VALUE)
    
                    ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:257:42: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
                 pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
    
                                          ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:257:42: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
                 pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
    
                                          ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:257:42: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
                 pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
    
                                          ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:258:19: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
             if(c->coded_frame->key_frame)
    
                   ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:258:19: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
             if(c->coded_frame->key_frame)
    
                   ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:258:19: warning: ‘AVCodecContext::coded_frame’ is deprecated [-Wdeprecated-declarations]
    
             if(c->coded_frame->key_frame)
    
                   ^
    
In file included from video.cpp:8:0:
    
./FFmpeg/libavcodec/avcodec.h:2723:35: note: declared here
    
     attribute_deprecated AVFrame *coded_frame;
    
                                   ^
    
video.cpp:357:40: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
         av_freep(&amp;context->streams[i]->codec);
    
                                        ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:357:40: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
         av_freep(&amp;context->streams[i]->codec);
    
                                        ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:357:40: warning: ‘AVStream::codec’ is deprecated [-Wdeprecated-declarations]
    
         av_freep(&amp;context->streams[i]->codec);
    
                                        ^
    
In file included from video.cpp:9:0:
    
./FFmpeg/libavformat/avformat.h:876:21: note: declared here
    
     AVCodecContext *codec;
    
                     ^
    
video.cpp:337:38: warning: ignoring return value of ‘int avformat_write_header(AVFormatContext*, AVDictionary**)’, declared with attribute warn_unused_result [-Wunused-result]
    
     avformat_write_header(context, 0);
    
                                      ^

    I have also defined a few macros to redefine those who have been omited. In a modern ffmpeg API, they must be replaced.

    Could someone please help me solving errors and deprecation warnings to comply with recent ffmpeg API ?

  • MKV Video Faster Plays Faster

    4 avril 2014, par Ankush

    I have C# program which screenshots 3 times per second & adds this to mkv ( VP8 ) video, set FPS to 3,encoded video works but plays faster, the total length of video player shows is wrong & while playing it doesn't plays smooth it jumps like from 1sec -> 3sec -> 5sec means instread of 1 -> 2 ->3..

    There is something wrong with pts value,

    if ( codecContext->coded_frame->pts != AV_NOPTS_VALUE )
    
{
    
 packet.pts = av_rescale_q( packet.pts, codecContext->time_base, pVideoStream->time_base );
    
}
    

    
if ( codecContext->coded_frame->pkt_dts != AV_NOPTS_VALUE )
    
{
    
 packet.dts = av_rescale_q( packet.dts, codecContext->time_base, pVideoStream->time_base );
    
}

    while debugging codecContext->time_base shows 3FPS ( num=1 den=3 ) & pVideoStream->time_base shows ( num=1 den=1000) & packet.pts & packet.dts shows 0 ( everytime )

    Whats wrong ? Anyone please give me some hint atleast.

  • ffmpeg mov to mp4 plays fine on linux no video on windows

    26 février 2018, par scopa

    I am using the cmd ffmpeg -i MAG.mov -c:a aac -strict -2 MAG.mp4

    On my linux box playback video & audio is fine. On Windows there is audio only. Any idea how to fix ?

Navigation