Recherche avancée
Médias (1)
-
Richard Stallman et le logiciel libre
19 octobre 2011, par
Mis à jour : Mai 2013
Langue : français
Type : Texte
Autres articles (30)
-
Support audio et vidéo HTML5
10 avril 2011MediaSPIP utilise les balises HTML5 video et audio pour la lecture de documents multimedia en profitant des dernières innovations du W3C supportées par les navigateurs modernes.
Pour les navigateurs plus anciens, le lecteur flash Flowplayer est utilisé.
Le lecteur HTML5 utilisé a été spécifiquement créé pour MediaSPIP : il est complètement modifiable graphiquement pour correspondre à un thème choisi.
Ces technologies permettent de distribuer vidéo et son à la fois sur des ordinateurs conventionnels (...) -
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 (...) -
De l’upload à la vidéo finale [version standalone]
31 janvier 2010, parLe chemin d’un document audio ou vidéo dans SPIPMotion est divisé en trois étapes distinctes.
Upload et récupération d’informations de la vidéo source
Dans un premier temps, il est nécessaire de créer un article SPIP et de lui joindre le document vidéo "source".
Au moment où ce document est joint à l’article, deux actions supplémentaires au comportement normal sont exécutées : La récupération des informations techniques des flux audio et video du fichier ; La génération d’une vignette : extraction d’une (...)
Sur d’autres sites (3175)
-
How to use ffmpeg for youtube stream ads for 2017 [on hold]
24 août 2017, par Trần Quang HọaCan anybody share me the code using the url of a video above any wed as input for ffmpeg so the stream output is not.
-
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 ? -
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
