FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
decoding_encoding.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001 Fabrice Bellard
3  *
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:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
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
20  * THE SOFTWARE.
21  */
22 
23 /**
24  * @file
25  * libavcodec API use example.
26  *
27  * @example decoding_encoding.c
28  * Note that libavcodec only handles codecs (mpeg, mpeg4, etc...),
29  * not file formats (avi, vob, mp4, mov, mkv, mxf, flv, mpegts, mpegps, etc...). See library 'libavformat' for the
30  * format handling
31  */
32 
33 #include <math.h>
34 
35 #include <libavutil/opt.h>
36 #include <libavcodec/avcodec.h>
38 #include <libavutil/common.h>
39 #include <libavutil/imgutils.h>
40 #include <libavutil/mathematics.h>
41 #include <libavutil/samplefmt.h>
42 
43 #define INBUF_SIZE 4096
44 #define AUDIO_INBUF_SIZE 20480
45 #define AUDIO_REFILL_THRESH 4096
46 
47 /* check that a given sample format is supported by the encoder */
48 static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
49 {
50  const enum AVSampleFormat *p = codec->sample_fmts;
51 
52  while (*p != AV_SAMPLE_FMT_NONE) {
53  if (*p == sample_fmt)
54  return 1;
55  p++;
56  }
57  return 0;
58 }
59 
60 /* just pick the highest supported samplerate */
61 static int select_sample_rate(AVCodec *codec)
62 {
63  const int *p;
64  int best_samplerate = 0;
65 
66  if (!codec->supported_samplerates)
67  return 44100;
68 
69  p = codec->supported_samplerates;
70  while (*p) {
71  best_samplerate = FFMAX(*p, best_samplerate);
72  p++;
73  }
74  return best_samplerate;
75 }
76 
77 /* select layout with the highest channel count */
78 static int select_channel_layout(AVCodec *codec)
79 {
80  const uint64_t *p;
81  uint64_t best_ch_layout = 0;
82  int best_nb_channels = 0;
83 
84  if (!codec->channel_layouts)
85  return AV_CH_LAYOUT_STEREO;
86 
87  p = codec->channel_layouts;
88  while (*p) {
90 
91  if (nb_channels > best_nb_channels) {
92  best_ch_layout = *p;
93  best_nb_channels = nb_channels;
94  }
95  p++;
96  }
97  return best_ch_layout;
98 }
99 
100 /*
101  * Audio encoding example
102  */
103 static void audio_encode_example(const char *filename)
104 {
105  AVCodec *codec;
107  AVFrame *frame;
108  AVPacket pkt;
109  int i, j, k, ret, got_output;
110  int buffer_size;
111  FILE *f;
112  uint16_t *samples;
113  float t, tincr;
114 
115  printf("Encode audio file %s\n", filename);
116 
117  /* find the MP2 encoder */
119  if (!codec) {
120  fprintf(stderr, "Codec not found\n");
121  exit(1);
122  }
123 
124  c = avcodec_alloc_context3(codec);
125  if (!c) {
126  fprintf(stderr, "Could not allocate audio codec context\n");
127  exit(1);
128  }
129 
130  /* put sample parameters */
131  c->bit_rate = 64000;
132 
133  /* check that the encoder supports s16 pcm input */
135  if (!check_sample_fmt(codec, c->sample_fmt)) {
136  fprintf(stderr, "Encoder does not support sample format %s",
138  exit(1);
139  }
140 
141  /* select other audio parameters supported by the encoder */
142  c->sample_rate = select_sample_rate(codec);
145 
146  /* open it */
147  if (avcodec_open2(c, codec, NULL) < 0) {
148  fprintf(stderr, "Could not open codec\n");
149  exit(1);
150  }
151 
152  f = fopen(filename, "wb");
153  if (!f) {
154  fprintf(stderr, "Could not open %s\n", filename);
155  exit(1);
156  }
157 
158  /* frame containing input raw audio */
159  frame = av_frame_alloc();
160  if (!frame) {
161  fprintf(stderr, "Could not allocate audio frame\n");
162  exit(1);
163  }
164 
165  frame->nb_samples = c->frame_size;
166  frame->format = c->sample_fmt;
167  frame->channel_layout = c->channel_layout;
168 
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,
172  c->sample_fmt, 0);
173  if (buffer_size < 0) {
174  fprintf(stderr, "Could not get sample buffer size\n");
175  exit(1);
176  }
177  samples = av_malloc(buffer_size);
178  if (!samples) {
179  fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",
180  buffer_size);
181  exit(1);
182  }
183  /* setup the data pointers in the AVFrame */
184  ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
185  (const uint8_t*)samples, buffer_size, 0);
186  if (ret < 0) {
187  fprintf(stderr, "Could not setup audio frame\n");
188  exit(1);
189  }
190 
191  /* encode a single tone sound */
192  t = 0;
193  tincr = 2 * M_PI * 440.0 / c->sample_rate;
194  for (i = 0; i < 200; i++) {
195  av_init_packet(&pkt);
196  pkt.data = NULL; // packet data will be allocated by the encoder
197  pkt.size = 0;
198 
199  for (j = 0; j < c->frame_size; j++) {
200  samples[2*j] = (int)(sin(t) * 10000);
201 
202  for (k = 1; k < c->channels; k++)
203  samples[2*j + k] = samples[2*j];
204  t += tincr;
205  }
206  /* encode the samples */
207  ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
208  if (ret < 0) {
209  fprintf(stderr, "Error encoding audio frame\n");
210  exit(1);
211  }
212  if (got_output) {
213  fwrite(pkt.data, 1, pkt.size, f);
214  av_free_packet(&pkt);
215  }
216  }
217 
218  /* get the delayed frames */
219  for (got_output = 1; got_output; i++) {
220  ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
221  if (ret < 0) {
222  fprintf(stderr, "Error encoding frame\n");
223  exit(1);
224  }
225 
226  if (got_output) {
227  fwrite(pkt.data, 1, pkt.size, f);
228  av_free_packet(&pkt);
229  }
230  }
231  fclose(f);
232 
233  av_freep(&samples);
234  av_frame_free(&frame);
235  avcodec_close(c);
236  av_free(c);
237 }
238 
239 /*
240  * Audio decoding.
241  */
242 static void audio_decode_example(const char *outfilename, const char *filename)
243 {
244  AVCodec *codec;
246  int len;
247  FILE *f, *outfile;
249  AVPacket avpkt;
250  AVFrame *decoded_frame = NULL;
251 
252  av_init_packet(&avpkt);
253 
254  printf("Decode audio file %s to %s\n", filename, outfilename);
255 
256  /* find the mpeg audio decoder */
258  if (!codec) {
259  fprintf(stderr, "Codec not found\n");
260  exit(1);
261  }
262 
263  c = avcodec_alloc_context3(codec);
264  if (!c) {
265  fprintf(stderr, "Could not allocate audio codec context\n");
266  exit(1);
267  }
268 
269  /* open it */
270  if (avcodec_open2(c, codec, NULL) < 0) {
271  fprintf(stderr, "Could not open codec\n");
272  exit(1);
273  }
274 
275  f = fopen(filename, "rb");
276  if (!f) {
277  fprintf(stderr, "Could not open %s\n", filename);
278  exit(1);
279  }
280  outfile = fopen(outfilename, "wb");
281  if (!outfile) {
282  av_free(c);
283  exit(1);
284  }
285 
286  /* decode until eof */
287  avpkt.data = inbuf;
288  avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
289 
290  while (avpkt.size > 0) {
291  int i, ch;
292  int got_frame = 0;
293 
294  if (!decoded_frame) {
295  if (!(decoded_frame = av_frame_alloc())) {
296  fprintf(stderr, "Could not allocate audio frame\n");
297  exit(1);
298  }
299  }
300 
301  len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
302  if (len < 0) {
303  fprintf(stderr, "Error while decoding\n");
304  exit(1);
305  }
306  if (got_frame) {
307  /* if a frame has been decoded, output it */
308  int data_size = av_get_bytes_per_sample(c->sample_fmt);
309  if (data_size < 0) {
310  /* This should not occur, checking just for paranoia */
311  fprintf(stderr, "Failed to calculate data size\n");
312  exit(1);
313  }
314  for (i=0; i<decoded_frame->nb_samples; i++)
315  for (ch=0; ch<c->channels; ch++)
316  fwrite(decoded_frame->data[ch] + data_size*i, 1, data_size, outfile);
317  }
318  avpkt.size -= len;
319  avpkt.data += len;
320  avpkt.dts =
321  avpkt.pts = AV_NOPTS_VALUE;
322  if (avpkt.size < AUDIO_REFILL_THRESH) {
323  /* Refill the input buffer, to avoid trying to decode
324  * incomplete frames. Instead of this, one could also use
325  * a parser, or use a proper container format through
326  * libavformat. */
327  memmove(inbuf, avpkt.data, avpkt.size);
328  avpkt.data = inbuf;
329  len = fread(avpkt.data + avpkt.size, 1,
330  AUDIO_INBUF_SIZE - avpkt.size, f);
331  if (len > 0)
332  avpkt.size += len;
333  }
334  }
335 
336  fclose(outfile);
337  fclose(f);
338 
339  avcodec_close(c);
340  av_free(c);
341  av_frame_free(&decoded_frame);
342 }
343 
344 /*
345  * Video encoding example
346  */
347 static void video_encode_example(const char *filename, int codec_id)
348 {
349  AVCodec *codec;
351  int i, ret, x, y, got_output;
352  FILE *f;
353  AVFrame *frame;
354  AVPacket pkt;
355  uint8_t endcode[] = { 0, 0, 1, 0xb7 };
356 
357  printf("Encode video file %s\n", filename);
358 
359  /* find the mpeg1 video encoder */
360  codec = avcodec_find_encoder(codec_id);
361  if (!codec) {
362  fprintf(stderr, "Codec not found\n");
363  exit(1);
364  }
365 
366  c = avcodec_alloc_context3(codec);
367  if (!c) {
368  fprintf(stderr, "Could not allocate video codec context\n");
369  exit(1);
370  }
371 
372  /* put sample parameters */
373  c->bit_rate = 400000;
374  /* resolution must be a multiple of two */
375  c->width = 352;
376  c->height = 288;
377  /* frames per second */
378  c->time_base = (AVRational){1,25};
379  /* emit one intra frame every ten frames
380  * check frame pict_type before passing frame
381  * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
382  * then gop_size is ignored and the output of encoder
383  * will always be I frame irrespective to gop_size
384  */
385  c->gop_size = 10;
386  c->max_b_frames = 1;
388 
389  if (codec_id == AV_CODEC_ID_H264)
390  av_opt_set(c->priv_data, "preset", "slow", 0);
391 
392  /* open it */
393  if (avcodec_open2(c, codec, NULL) < 0) {
394  fprintf(stderr, "Could not open codec\n");
395  exit(1);
396  }
397 
398  f = fopen(filename, "wb");
399  if (!f) {
400  fprintf(stderr, "Could not open %s\n", filename);
401  exit(1);
402  }
403 
404  frame = av_frame_alloc();
405  if (!frame) {
406  fprintf(stderr, "Could not allocate video frame\n");
407  exit(1);
408  }
409  frame->format = c->pix_fmt;
410  frame->width = c->width;
411  frame->height = c->height;
412 
413  /* the image can be allocated by any means and av_image_alloc() is
414  * just the most convenient way if av_malloc() is to be used */
415  ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
416  c->pix_fmt, 32);
417  if (ret < 0) {
418  fprintf(stderr, "Could not allocate raw picture buffer\n");
419  exit(1);
420  }
421 
422  /* encode 1 second of video */
423  for (i = 0; i < 25; i++) {
424  av_init_packet(&pkt);
425  pkt.data = NULL; // packet data will be allocated by the encoder
426  pkt.size = 0;
427 
428  fflush(stdout);
429  /* prepare a dummy image */
430  /* Y */
431  for (y = 0; y < c->height; y++) {
432  for (x = 0; x < c->width; x++) {
433  frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
434  }
435  }
436 
437  /* Cb and Cr */
438  for (y = 0; y < c->height/2; y++) {
439  for (x = 0; x < c->width/2; x++) {
440  frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
441  frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
442  }
443  }
444 
445  frame->pts = i;
446 
447  /* encode the image */
448  ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
449  if (ret < 0) {
450  fprintf(stderr, "Error encoding frame\n");
451  exit(1);
452  }
453 
454  if (got_output) {
455  printf("Write frame %3d (size=%5d)\n", i, pkt.size);
456  fwrite(pkt.data, 1, pkt.size, f);
457  av_free_packet(&pkt);
458  }
459  }
460 
461  /* get the delayed frames */
462  for (got_output = 1; got_output; i++) {
463  fflush(stdout);
464 
465  ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
466  if (ret < 0) {
467  fprintf(stderr, "Error encoding frame\n");
468  exit(1);
469  }
470 
471  if (got_output) {
472  printf("Write frame %3d (size=%5d)\n", i, pkt.size);
473  fwrite(pkt.data, 1, pkt.size, f);
474  av_free_packet(&pkt);
475  }
476  }
477 
478  /* add sequence end code to have a real mpeg file */
479  fwrite(endcode, 1, sizeof(endcode), f);
480  fclose(f);
481 
482  avcodec_close(c);
483  av_free(c);
484  av_freep(&frame->data[0]);
485  av_frame_free(&frame);
486  printf("\n");
487 }
488 
489 /*
490  * Video decoding example
491  */
492 
493 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
494  char *filename)
495 {
496  FILE *f;
497  int i;
498 
499  f = fopen(filename,"w");
500  fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
501  for (i = 0; i < ysize; i++)
502  fwrite(buf + i * wrap, 1, xsize, f);
503  fclose(f);
504 }
505 
506 static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,
507  AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
508 {
509  int len, got_frame;
510  char buf[1024];
511 
512  len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
513  if (len < 0) {
514  fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
515  return len;
516  }
517  if (got_frame) {
518  printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);
519  fflush(stdout);
520 
521  /* the picture is allocated by the decoder, no need to free it */
522  snprintf(buf, sizeof(buf), outfilename, *frame_count);
523  pgm_save(frame->data[0], frame->linesize[0],
524  avctx->width, avctx->height, buf);
525  (*frame_count)++;
526  }
527  if (pkt->data) {
528  pkt->size -= len;
529  pkt->data += len;
530  }
531  return 0;
532 }
533 
534 static void video_decode_example(const char *outfilename, const char *filename)
535 {
536  AVCodec *codec;
538  int frame_count;
539  FILE *f;
540  AVFrame *frame;
542  AVPacket avpkt;
543 
544  av_init_packet(&avpkt);
545 
546  /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
547  memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
548 
549  printf("Decode video file %s to %s\n", filename, outfilename);
550 
551  /* find the mpeg1 video decoder */
553  if (!codec) {
554  fprintf(stderr, "Codec not found\n");
555  exit(1);
556  }
557 
558  c = avcodec_alloc_context3(codec);
559  if (!c) {
560  fprintf(stderr, "Could not allocate video codec context\n");
561  exit(1);
562  }
563 
565  c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
566 
567  /* For some codecs, such as msmpeg4 and mpeg4, width and height
568  MUST be initialized there because this information is not
569  available in the bitstream. */
570 
571  /* open it */
572  if (avcodec_open2(c, codec, NULL) < 0) {
573  fprintf(stderr, "Could not open codec\n");
574  exit(1);
575  }
576 
577  f = fopen(filename, "rb");
578  if (!f) {
579  fprintf(stderr, "Could not open %s\n", filename);
580  exit(1);
581  }
582 
583  frame = av_frame_alloc();
584  if (!frame) {
585  fprintf(stderr, "Could not allocate video frame\n");
586  exit(1);
587  }
588 
589  frame_count = 0;
590  for (;;) {
591  avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
592  if (avpkt.size == 0)
593  break;
594 
595  /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
596  and this is the only method to use them because you cannot
597  know the compressed data size before analysing it.
598 
599  BUT some other codecs (msmpeg4, mpeg4) are inherently frame
600  based, so you must call them with all the data for one
601  frame exactly. You must also initialize 'width' and
602  'height' before initializing them. */
603 
604  /* NOTE2: some codecs allow the raw parameters (frame size,
605  sample rate) to be changed at any frame. We handle this, so
606  you should also take care of it */
607 
608  /* here, we use a stream based decoder (mpeg1video), so we
609  feed decoder and see if it could decode a frame */
610  avpkt.data = inbuf;
611  while (avpkt.size > 0)
612  if (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)
613  exit(1);
614  }
615 
616  /* some codecs, such as MPEG, transmit the I and P frame with a
617  latency of one frame. You must do the following to have a
618  chance to get the last frame of the video */
619  avpkt.data = NULL;
620  avpkt.size = 0;
621  decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 1);
622 
623  fclose(f);
624 
625  avcodec_close(c);
626  av_free(c);
627  av_frame_free(&frame);
628  printf("\n");
629 }
630 
631 int main(int argc, char **argv)
632 {
633  const char *output_type;
634 
635  /* register all the codecs */
637 
638  if (argc < 2) {
639  printf("usage: %s output_type\n"
640  "API example program to decode/encode a media stream with libavcodec.\n"
641  "This program generates a synthetic stream and encodes it to a file\n"
642  "named test.h264, test.mp2 or test.mpg depending on output_type.\n"
643  "The encoded stream is then decoded and written to a raw data output.\n"
644  "output_type must be chosen between 'h264', 'mp2', 'mpg'.\n",
645  argv[0]);
646  return 1;
647  }
648  output_type = argv[1];
649 
650  if (!strcmp(output_type, "h264")) {
652  } else if (!strcmp(output_type, "mp2")) {
653  audio_encode_example("test.mp2");
654  audio_decode_example("test.pcm", "test.mp2");
655  } else if (!strcmp(output_type, "mpg")) {
657  video_decode_example("test%02d.pgm", "test.mpg");
658  } else {
659  fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",
660  output_type);
661  return 1;
662  }
663 
664  return 0;
665 }