Recherche avancée
Médias (17)
-
Matmos - Action at a Distance
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
DJ Dolores - Oslodum 2004 (includes (cc) sample of “Oslodum” by Gilberto Gil)
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
Danger Mouse & Jemini - What U Sittin’ On ? (starring Cee Lo and Tha Alkaholiks)
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
Cornelius - Wataridori 2
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
The Rapture - Sister Saviour (Blackstrobe Remix)
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
Chuck D with Fine Arts Militia - No Meaning No
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
Autres articles (64)
-
Publier sur MédiaSpip
13 juin 2013Puis-je poster des contenus à partir d’une tablette Ipad ?
Oui, si votre Médiaspip installé est à la version 0.2 ou supérieure. Contacter au besoin l’administrateur de votre MédiaSpip pour le savoir -
Ajouter notes et légendes aux images
7 février 2011, parPour pouvoir ajouter notes et légendes aux images, la première étape est d’installer le plugin "Légendes".
Une fois le plugin activé, vous pouvez le configurer dans l’espace de configuration afin de modifier les droits de création / modification et de suppression des notes. Par défaut seuls les administrateurs du site peuvent ajouter des notes aux images.
Modification lors de l’ajout d’un média
Lors de l’ajout d’un média de type "image" un nouveau bouton apparait au dessus de la prévisualisation (...) -
MediaSPIP 0.1 Beta version
25 avril 2011, parMediaSPIP 0.1 beta is the first version of MediaSPIP proclaimed as "usable".
The zip file provided here only contains the sources of MediaSPIP in its standalone version.
To get a working installation, you must manually install all-software dependencies on the server.
If you want to use this archive for an installation in "farm mode", you will also need to proceed to other manual (...)
Sur d’autres sites (9129)
-
Consent Mode v2 : Everything You Need to Know
7 mai 2024, par Alex — Analytics TipsConfused about Consent Mode v2 and its impact on your website analytics ? You’re not the only one.
Google’s latest update has left many scratching their heads about data privacy and tracking.
In this blog, we’re getting straight to the point. We’ll break down what Consent Mode v2 is, how it works, and the impact it has.
What is Consent Mode ?
What exaclty is Google Consent Mode and why is there so much buzz surrounding it ? This question has been frustrating analysts and marketers worldwide since the beginning of this year.
Consent Mode is the solution from Google designed to manage data collection on websites in accordance with user privacy requirements.
This mode enables website owners to customise how Google tags respond to users’ consent status for cookie usage. At its core, Consent Mode adheres to privacy regulations such as GDPR in Europe and CCPA in California, without significant loss of analytical data.
How does Consent Mode work ?
Consent Mode operates by adjusting the behaviour of tags on a website depending on whether consent for cookie usage is provided or not. If a user does not consent to the use of analytical or advertising cookies, Google tags automatically switch to collecting a limited amount of data, ensuring privacy compliance.
This approach allows for continued valuable insights into website traffic and user behavior, even if users opt out of most tracking cookies.
What types of consent are available in Consent Mode ?
As of 6 March 2024, Consent Mode v2 has become the current standard (and in terms of utilising Google Advertising Services, practically mandatory), indicating the incorporation of four consent types :
- ad_storage : allows for the collection and storage of data necessary for delivering personalised ads based on user actions.
- ad_user_data : pertains to the collection and usage of data that can be associated with the user for ad customisation and optimisation.
- ad_personalization : permits the use of user data for ad personalisation and providing more relevant content.
- analytics_storage : relates to the collection and storage of data for analytics, enabling websites to analyse user behaviour and enhance user experience.
Additionally, in Consent Mode v2, there are two modes :
- Basic Consent Mode : in which Google tags are not used for personalised advertising and measurements if consent is not obtained.
- Advanced Consent Mode : allows Google tags to utilise anonymised data for personalised advertising campaigns and measurements, even if consent is not obtained.
What is Consent Mode v2 ? (And how does it differ from Consent Mode v1 ?)
Consent Mode v2 is an improved version of the original Consent Mode, offering enhanced customisation capabilities and better compliance with privacy requirements.
The new version introduces additional consent configuration parameters, allowing for even more precise control over which data is collected and how it’s used. The key difference between Consent Mode v2 and Consent Mode v1 lies in more granular consent management, making this tool even more flexible and powerful in safeguarding personal data.
In Consent Mode v2, the existing markers (ad_storage and analytics_storage) are accompanied by two new markers :
- ad_user_data – does the user agree to their personal data being utilized for advertising purposes ?
- ad_personalization – does the user agree to their data being employed for remarketing ?
In contrast to ad_storage and analytics_storage, these markers don’t directly affect how the tags operate on the site itself.
They serve as additional directives sent alongside the pings to Google services, indicating how user data can be utilised for advertising purposes.
While ad_storage and analytics_storage serve as upstream qualifiers for data (determining which identifiers are sent with the pings), ad_user_data and ad_personalization serve as downstream instructions for Google services regarding data processing.
How is the implementation of Consent Mode v2 going ?
The implementation of Consent Mode v2 is encountering some issues and bugs (as expected). The most important thing to understand :
- Advanced Consent Mode v2 is essential if you have traffic and campaigns with Google Ads in the European Union.
- If you don’t have substantially large traffic, enabling Advanced Consent Mode v2 will likely result in a traffic drop in GA4 – because this version of consent mode (unlike the basic one) applies behavioural modelling to users who haven’t accepted the use of cookies. And modelling the behaviour requires time.
The aspect of behavioural modelling in Consent Mode v2 implies the following : the data of users who have declined tracking options begin to be modelled using machine learning.
However, training the model requires a suitable data volume. As the Google’s documentation states :
The property should collect at least 1,000 events per day with analytics_storage=’denied’ for at least 7 days. The property should have at least 1,000 daily users submitting events with analytics_storage=’granted’ for at least 7 of the previous 28 days.
Largely due to this, the market’s response to the Consent Mode v2 implementation was mixed : many reported a significant drop in traffic in their GA4 and Google Ads reports upon enabling the Advanced mode. Essentially, a portion of the data was lost because Google’s models lacked enough data for training.
And from the very beginning of implementation, users regularly report about a few examples of that scenario. If your website doesn’t have enough traffic for behaviour modelling, after Consent Mode v2 switching you will face significant drop in your traffic in Google Ads and GA4 reports. There are a lot of cases of observing 90-95% drop in metrics of users and sessions.
In a nutshell, you should be prepared for significant data losses if you are planning to switch to Google Consent Mode v2.
How does Consent Mode v2 impact web analytics ?
The transition to Consent Mode v2 alters the methods of user data collection and processing. The main concerns arise from the potential loss of accuracy and completeness of analytical data due to restrictions on the use of cookies and other identifiers when user consent is absent.
With Google Consent Mode v2, the data of visitors who have not agreed to tracking will be modelled and may not accurately reflect your actual visitors’ behaviours and actions. So as an analyst or marketer, you will not have true insights into these visitors and the data acquired will be more generalised and less accurate.
Google Consent Mode v2 appears to be a kind of compromise band-aid solution.
It tries to solve these issues by using data modelling and anonymised data collection. However, it’s critical to note that there are specific limitations inherent to the modelling mechanism.
This complicates the analysis of visitor behavior, advertising campaigns, and website optimisation, ultimately impacting decision-making and resulting in poor website performance and marketing outcomes.
Wrap up
Consent Mode v2 is a mechanism of managing Google tag operations based on user consent settings.
It’s mandatory if you’re using Google’s advertising services, and optional (at least for Advanced mode) if you don’t advertise on Google Ads.
There are particular indications that this technology is unreliable from a GDPR perspective.
Using Google Consent Mode will inevitably lead to data losses and inaccuracies in its analysis.
In other words, it in some sense jeopardises your business.
-
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 ?

-
Video creation with a recent ffmpeg API (2017)
16 novembre 2017, 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 -lavformatThe 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
