2 * Copyright (c) 2001 Fabrice Bellard
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 * libavcodec API use example.
27 * Note that libavcodec only handles codecs (mpeg, mpeg4, etc...),
28 * not file formats (avi, vob, mp4, mov, mkv, mxf, flv, mpegts, mpegps, etc...). See library 'libavformat' for the
30 * @example doc/examples/decoding_encoding.c
35 #include <libavutil/opt.h>
36 #include <libavcodec/avcodec.h>
37 #include <libavutil/channel_layout.h>
38 #include <libavutil/common.h>
39 #include <libavutil/imgutils.h>
40 #include <libavutil/mathematics.h>
41 #include <libavutil/samplefmt.h>
43 #define INBUF_SIZE 4096
44 #define AUDIO_INBUF_SIZE 20480
45 #define AUDIO_REFILL_THRESH 4096
47 /* check that a given sample format is supported by the encoder */
48 static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
50 const enum AVSampleFormat *p = codec->sample_fmts;
52 while (*p != AV_SAMPLE_FMT_NONE) {
60 /* just pick the highest supported samplerate */
61 static int select_sample_rate(AVCodec *codec)
64 int best_samplerate = 0;
66 if (!codec->supported_samplerates)
69 p = codec->supported_samplerates;
71 best_samplerate = FFMAX(*p, best_samplerate);
74 return best_samplerate;
77 /* select layout with the highest channel count */
78 static int select_channel_layout(AVCodec *codec)
81 uint64_t best_ch_layout = 0;
82 int best_nb_channels = 0;
84 if (!codec->channel_layouts)
85 return AV_CH_LAYOUT_STEREO;
87 p = codec->channel_layouts;
89 int nb_channels = av_get_channel_layout_nb_channels(*p);
91 if (nb_channels > best_nb_channels) {
93 best_nb_channels = nb_channels;
97 return best_ch_layout;
101 * Audio encoding example
103 static void audio_encode_example(const char *filename)
106 AVCodecContext *c= NULL;
109 int i, j, k, ret, got_output;
115 printf("Encode audio file %s\n", filename);
117 /* find the MP2 encoder */
118 codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
120 fprintf(stderr, "Codec not found\n");
124 c = avcodec_alloc_context3(codec);
126 fprintf(stderr, "Could not allocate audio codec context\n");
130 /* put sample parameters */
133 /* check that the encoder supports s16 pcm input */
134 c->sample_fmt = AV_SAMPLE_FMT_S16;
135 if (!check_sample_fmt(codec, c->sample_fmt)) {
136 fprintf(stderr, "Encoder does not support sample format %s",
137 av_get_sample_fmt_name(c->sample_fmt));
141 /* select other audio parameters supported by the encoder */
142 c->sample_rate = select_sample_rate(codec);
143 c->channel_layout = select_channel_layout(codec);
144 c->channels = av_get_channel_layout_nb_channels(c->channel_layout);
147 if (avcodec_open2(c, codec, NULL) < 0) {
148 fprintf(stderr, "Could not open codec\n");
152 f = fopen(filename, "wb");
154 fprintf(stderr, "Could not open %s\n", filename);
158 /* frame containing input raw audio */
159 frame = av_frame_alloc();
161 fprintf(stderr, "Could not allocate audio frame\n");
165 frame->nb_samples = c->frame_size;
166 frame->format = c->sample_fmt;
167 frame->channel_layout = c->channel_layout;
169 /* the codec gives us the frame size, in samples,
170 * we calculate the size of the samples buffer in bytes */
171 buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
173 samples = av_malloc(buffer_size);
175 fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",
179 /* setup the data pointers in the AVFrame */
180 ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
181 (const uint8_t*)samples, buffer_size, 0);
183 fprintf(stderr, "Could not setup audio frame\n");
187 /* encode a single tone sound */
189 tincr = 2 * M_PI * 440.0 / c->sample_rate;
191 av_init_packet(&pkt);
192 pkt.data = NULL; // packet data will be allocated by the encoder
195 for (j = 0; j < c->frame_size; j++) {
196 samples[2*j] = (int)(sin(t) * 10000);
198 for (k = 1; k < c->channels; k++)
199 samples[2*j + k] = samples[2*j];
202 /* encode the samples */
203 ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
205 fprintf(stderr, "Error encoding audio frame\n");
209 fwrite(pkt.data, 1, pkt.size, f);
210 av_free_packet(&pkt);
214 /* get the delayed frames */
215 for (got_output = 1; got_output; i++) {
216 ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
218 fprintf(stderr, "Error encoding frame\n");
223 fwrite(pkt.data, 1, pkt.size, f);
224 av_free_packet(&pkt);
230 avcodec_free_frame(&frame);
238 static void audio_decode_example(const char *outfilename, const char *filename)
241 AVCodecContext *c= NULL;
244 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
246 AVFrame *decoded_frame = NULL;
248 av_init_packet(&avpkt);
250 printf("Decode audio file %s to %s\n", filename, outfilename);
252 /* find the mpeg audio decoder */
253 codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
255 fprintf(stderr, "Codec not found\n");
259 c = avcodec_alloc_context3(codec);
261 fprintf(stderr, "Could not allocate audio codec context\n");
266 if (avcodec_open2(c, codec, NULL) < 0) {
267 fprintf(stderr, "Could not open codec\n");
271 f = fopen(filename, "rb");
273 fprintf(stderr, "Could not open %s\n", filename);
276 outfile = fopen(outfilename, "wb");
282 /* decode until eof */
284 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
286 while (avpkt.size > 0) {
289 if (!decoded_frame) {
290 if (!(decoded_frame = av_frame_alloc())) {
291 fprintf(stderr, "Could not allocate audio frame\n");
295 avcodec_get_frame_defaults(decoded_frame);
297 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
299 fprintf(stderr, "Error while decoding\n");
303 /* if a frame has been decoded, output it */
304 int data_size = av_samples_get_buffer_size(NULL, c->channels,
305 decoded_frame->nb_samples,
307 fwrite(decoded_frame->data[0], 1, data_size, outfile);
312 avpkt.pts = AV_NOPTS_VALUE;
313 if (avpkt.size < AUDIO_REFILL_THRESH) {
314 /* Refill the input buffer, to avoid trying to decode
315 * incomplete frames. Instead of this, one could also use
316 * a parser, or use a proper container format through
318 memmove(inbuf, avpkt.data, avpkt.size);
320 len = fread(avpkt.data + avpkt.size, 1,
321 AUDIO_INBUF_SIZE - avpkt.size, f);
332 avcodec_free_frame(&decoded_frame);
336 * Video encoding example
338 static void video_encode_example(const char *filename, int codec_id)
341 AVCodecContext *c= NULL;
342 int i, ret, x, y, got_output;
346 uint8_t endcode[] = { 0, 0, 1, 0xb7 };
348 printf("Encode video file %s\n", filename);
350 /* find the mpeg1 video encoder */
351 codec = avcodec_find_encoder(codec_id);
353 fprintf(stderr, "Codec not found\n");
357 c = avcodec_alloc_context3(codec);
359 fprintf(stderr, "Could not allocate video codec context\n");
363 /* put sample parameters */
364 c->bit_rate = 400000;
365 /* resolution must be a multiple of two */
368 /* frames per second */
369 c->time_base= (AVRational){1,25};
370 c->gop_size = 10; /* emit one intra frame every ten frames */
372 c->pix_fmt = AV_PIX_FMT_YUV420P;
374 if(codec_id == AV_CODEC_ID_H264)
375 av_opt_set(c->priv_data, "preset", "slow", 0);
378 if (avcodec_open2(c, codec, NULL) < 0) {
379 fprintf(stderr, "Could not open codec\n");
383 f = fopen(filename, "wb");
385 fprintf(stderr, "Could not open %s\n", filename);
389 frame = av_frame_alloc();
391 fprintf(stderr, "Could not allocate video frame\n");
394 frame->format = c->pix_fmt;
395 frame->width = c->width;
396 frame->height = c->height;
398 /* the image can be allocated by any means and av_image_alloc() is
399 * just the most convenient way if av_malloc() is to be used */
400 ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
403 fprintf(stderr, "Could not allocate raw picture buffer\n");
407 /* encode 1 second of video */
409 av_init_packet(&pkt);
410 pkt.data = NULL; // packet data will be allocated by the encoder
414 /* prepare a dummy image */
416 for(y=0;y<c->height;y++) {
417 for(x=0;x<c->width;x++) {
418 frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
423 for(y=0;y<c->height/2;y++) {
424 for(x=0;x<c->width/2;x++) {
425 frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
426 frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
432 /* encode the image */
433 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
435 fprintf(stderr, "Error encoding frame\n");
440 printf("Write frame %3d (size=%5d)\n", i, pkt.size);
441 fwrite(pkt.data, 1, pkt.size, f);
442 av_free_packet(&pkt);
446 /* get the delayed frames */
447 for (got_output = 1; got_output; i++) {
450 ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
452 fprintf(stderr, "Error encoding frame\n");
457 printf("Write frame %3d (size=%5d)\n", i, pkt.size);
458 fwrite(pkt.data, 1, pkt.size, f);
459 av_free_packet(&pkt);
463 /* add sequence end code to have a real mpeg file */
464 fwrite(endcode, 1, sizeof(endcode), f);
469 av_freep(&frame->data[0]);
470 avcodec_free_frame(&frame);
475 * Video decoding example
478 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
484 f=fopen(filename,"w");
485 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
487 fwrite(buf + i * wrap,1,xsize,f);
491 static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,
492 AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
497 len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
499 fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
503 printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);
506 /* the picture is allocated by the decoder, no need to free it */
507 snprintf(buf, sizeof(buf), outfilename, *frame_count);
508 pgm_save(frame->data[0], frame->linesize[0],
509 avctx->width, avctx->height, buf);
519 static void video_decode_example(const char *outfilename, const char *filename)
522 AVCodecContext *c= NULL;
526 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
529 av_init_packet(&avpkt);
531 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
532 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
534 printf("Decode video file %s to %s\n", filename, outfilename);
536 /* find the mpeg1 video decoder */
537 codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
539 fprintf(stderr, "Codec not found\n");
543 c = avcodec_alloc_context3(codec);
545 fprintf(stderr, "Could not allocate video codec context\n");
549 if(codec->capabilities&CODEC_CAP_TRUNCATED)
550 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
552 /* For some codecs, such as msmpeg4 and mpeg4, width and height
553 MUST be initialized there because this information is not
554 available in the bitstream. */
557 if (avcodec_open2(c, codec, NULL) < 0) {
558 fprintf(stderr, "Could not open codec\n");
562 f = fopen(filename, "rb");
564 fprintf(stderr, "Could not open %s\n", filename);
568 frame = av_frame_alloc();
570 fprintf(stderr, "Could not allocate video frame\n");
576 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
580 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
581 and this is the only method to use them because you cannot
582 know the compressed data size before analysing it.
584 BUT some other codecs (msmpeg4, mpeg4) are inherently frame
585 based, so you must call them with all the data for one
586 frame exactly. You must also initialize 'width' and
587 'height' before initializing them. */
589 /* NOTE2: some codecs allow the raw parameters (frame size,
590 sample rate) to be changed at any frame. We handle this, so
591 you should also take care of it */
593 /* here, we use a stream based decoder (mpeg1video), so we
594 feed decoder and see if it could decode a frame */
596 while (avpkt.size > 0)
597 if (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)
601 /* some codecs, such as MPEG, transmit the I and P frame with a
602 latency of one frame. You must do the following to have a
603 chance to get the last frame of the video */
606 decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 1);
612 avcodec_free_frame(&frame);
616 int main(int argc, char **argv)
618 const char *output_type;
620 /* register all the codecs */
621 avcodec_register_all();
624 printf("usage: %s output_type\n"
625 "API example program to decode/encode a media stream with libavcodec.\n"
626 "This program generates a synthetic stream and encodes it to a file\n"
627 "named test.h264, test.mp2 or test.mpg depending on output_type.\n"
628 "The encoded stream is then decoded and written to a raw data output.\n"
629 "output_type must be choosen between 'h264', 'mp2', 'mpg'.\n",
633 output_type = argv[1];
635 if (!strcmp(output_type, "h264")) {
636 video_encode_example("test.h264", AV_CODEC_ID_H264);
637 } else if (!strcmp(output_type, "mp2")) {
638 audio_encode_example("test.mp2");
639 audio_decode_example("test.sw", "test.mp2");
640 } else if (!strcmp(output_type, "mpg")) {
641 video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);
642 video_decode_example("test%02d.pgm", "test.mpg");
644 fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",