Recherche avancée
Médias (1)
-
The pirate bay depuis la Belgique
1er avril 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Image
Autres articles (61)
-
Des sites réalisés avec MediaSPIP
2 mai 2011, parCette page présente quelques-uns des sites fonctionnant sous MediaSPIP.
Vous pouvez bien entendu ajouter le votre grâce au formulaire en bas de page. -
Problèmes fréquents
10 mars 2010, parPHP et safe_mode activé
Une des principales sources de problèmes relève de la configuration de PHP et notamment de l’activation du safe_mode
La solution consiterait à soit désactiver le safe_mode soit placer le script dans un répertoire accessible par apache pour le site -
HTML5 audio and video support
13 avril 2011, parMediaSPIP uses HTML5 video and audio tags to play multimedia files, taking advantage of the latest W3C innovations supported by modern browsers.
The MediaSPIP player used has been created specifically for MediaSPIP and can be easily adapted to fit in with a specific theme.
For older browsers the Flowplayer flash fallback is used.
MediaSPIP allows for media playback on major mobile platforms with the above (...)
Sur d’autres sites (10983)
-
Revision 104616 : Version 1.2.2 (2017-05-23) - Lorsque deux (ou plus) formulaires ...
11 juin 2018, par kent1@… — LogVersion 1.2.2 (2017-05-23)
Lorsque deux (ou plus) formulaires utilisant mutilang sont dans la même page, l’un des deux perdait la fonctionnalité de numéro de titre, exemple sur la page de rubrique ayant un document, le document perdait cette fonctionnalité.
remplacer les .find('li.editer_titre_numero,div.editer_titre_numero')par.find('.editer_titre_numero')qui suffisent. Passer pour la forme la version de schemaen 3 chiffres. -
avfilter/vf_convolve : unbreak non-power of 2 width&height filtering
23 décembre 2017, par Paul B Mahol -
Video creation with the most recent ffmpeg API (2017)
19 octobre 2022, par ar2015I have started learning how to work with
ffmpegwhich 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 << 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 (&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 << "Codec not found." << 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) < 0)
 {
 std::cout << "Could not open codec." << std::endl;
 std::cin.get();std::cin.get();exit(1);
 }
 video_outbuf = NULL;
 if(!(oc->oformat->flags & 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 << "Could not allocate picture" << 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 << " Could not allocate temporary picture" << 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 << "Could not alloc stream." << 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 & 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 << "Cannot initialize the conversion context" << 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 & AVFMT_RAWPICTURE)
 {
 /* raw video case. The API will change slightly in the near
 futur for that */
 AVPacket pkt;
 av_init_packet(&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, &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(&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, &pkt);
 } else {
 ret = 0;
 }
 }
 if (ret != 0) {
 std::cout << "Error while writing video frames" << 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 << "Cannot guess output format! Using mpeg!" << std::endl;
 std::cin.get();
 outputFormat = av_guess_format(NULL, "h263" , NULL);
 }
 if(!outputFormat)
 {
 std::cout << "Could not find suitable output format." << std::endl;
 std::cin.get();exit(1);
 }

 context = avformat_alloc_context();
 if(!context)
 {
 std::cout << "Cannot allocate avformat memory." << std::endl;
 std::cin.get();exit(1);
 }
 context->oformat = outputFormat;
 sprintf_s(context->filename, sizeof(context->filename), "%s", filename);
 std::cout << "Is '" << context->filename << "' = '" << filename << "'" << 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) < 0)
 {
 std::cout << "Invalid output format parameters." << std::endl;
 exit(0);
 }*/

 av_dump_format(context, 0, filename, 1);

 if(videoStream)
 openVideo(context, videoStream);

 if(!outputFormat->flags & AVFMT_NOFILE)
 {
 if(avio_open(&context->pb, filename, AVIO_FLAG_READ_WRITE) < 0)
 {
 std::cout << "Could not open " << filename << 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 < context->nb_streams; i++)
 {
 av_freep(&context->streams[i]->codec);
 av_freep(&context->streams[i]);
 }

 if(!(outputFormat->flags & 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(&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(&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(&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
ffmpegAPI, they must be replaced.


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

Syndiquer tout le site
