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 }
static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
#define NULL
Definition: coverity.c:32
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:280
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:2932
misc image utilities
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)
Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...
Definition: imgutils.c:192
#define CODEC_CAP_TRUNCATED
Definition: avcodec.h:790
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1503
int size
Definition: avcodec.h:1163
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1444
static void video_decode_example(const char *outfilename, const char *filename)
static AVPacket pkt
int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of audio.
Definition: utils.c:1837
#define AV_CH_LAYOUT_STEREO
void avcodec_register_all(void)
Register all the codecs, parsers and bitstream filters which were enabled at configuration time...
Definition: allcodecs.c:68
AVCodec.
Definition: avcodec.h:3181
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1369
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, enum AVSampleFormat sample_fmt, const uint8_t *buf, int buf_size, int align)
Fill AVFrame audio data and linesize pointers.
Definition: utils.c:478
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1993
uint8_t
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
AVOptions.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:257
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: utils.c:2101
static AVFrame * frame
uint8_t * data
Definition: avcodec.h:1162
static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize, char *filename)
static int select_sample_rate(AVCodec *codec)
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:2843
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: avcodec.h:3205
#define CODEC_FLAG_TRUNCATED
Definition: avcodec.h:747
int width
width and height of the video frame
Definition: frame.h:220
int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: utils.c:2352
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
int capabilities
Codec capabilities.
Definition: avcodec.h:3200
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1335
#define wrap(func)
Definition: neontest.h:62
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:47
enum AVCodecID codec_id
Definition: mov_chan.c:433
#define FFMAX(a, b)
Definition: common.h:64
#define AUDIO_REFILL_THRESH
Libavcodec external API header.
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2046
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:427
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:630
int bit_rate
the average bitrate
Definition: avcodec.h:1305
audio channel layout utility functions
float y
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:147
ret
Definition: avfilter.c:974
int width
picture width / height.
Definition: avcodec.h:1414
static void audio_encode_example(const char *filename)
int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: utils.c:2498
static void video_encode_example(const char *filename, int codec_id)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:232
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2005
static int decode_write_frame(const char *outfilename, AVCodecContext *avctx, AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:59
int main(int argc, char **argv)
int sample_rate
samples per second
Definition: avcodec.h:1985
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
main external API structure.
Definition: avcodec.h:1241
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:2951
void * buf
Definition: avisynth_c.h:553
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:117
rational number numerator/denominator
Definition: rational.h:43
static void audio_decode_example(const char *outfilename, const char *filename)
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:1330
#define snprintf
Definition: snprintf.h:34
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:104
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1435
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
common internal and external API header
signed 16 bits
Definition: samplefmt.h:62
static double c[64]
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:49
#define INBUF_SIZE
void * priv_data
Definition: avcodec.h:1283
#define av_free(p)
int len
int channels
number of audio channels
Definition: avcodec.h:1986
static int select_channel_layout(AVCodec *codec)
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0 ...
Definition: avcodec.h:3203
#define AUDIO_INBUF_SIZE
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1161
int height
Definition: frame.h:220
#define av_freep(p)
#define M_PI
Definition: mathematics.h:46
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3204
int nb_channels
This structure stores compressed data.
Definition: avcodec.h:1139
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:369
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:225
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1155
FILE * outfile
Definition: audiogen.c:96
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:241