Libav
avcodec.c
Go to the documentation of this file.
1 /*
2  * copyright (c) 2001 Fabrice Bellard
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <string.h>
34 
35 #ifdef HAVE_AV_CONFIG_H
36 #undef HAVE_AV_CONFIG_H
37 #endif
38 
39 #include "libavcodec/avcodec.h"
41 #include "libavutil/common.h"
42 #include "libavutil/imgutils.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/samplefmt.h"
45 
46 #define INBUF_SIZE 4096
47 #define AUDIO_INBUF_SIZE 20480
48 #define AUDIO_REFILL_THRESH 4096
49 
50 /* check that a given sample format is supported by the encoder */
52 {
53  const enum AVSampleFormat *p = codec->sample_fmts;
54 
55  while (*p != AV_SAMPLE_FMT_NONE) {
56  if (*p == sample_fmt)
57  return 1;
58  p++;
59  }
60  return 0;
61 }
62 
63 /* just pick the highest supported samplerate */
64 static int select_sample_rate(AVCodec *codec)
65 {
66  const int *p;
67  int best_samplerate = 0;
68 
69  if (!codec->supported_samplerates)
70  return 44100;
71 
72  p = codec->supported_samplerates;
73  while (*p) {
74  best_samplerate = FFMAX(*p, best_samplerate);
75  p++;
76  }
77  return best_samplerate;
78 }
79 
80 /* select layout with the highest channel count */
81 static int select_channel_layout(AVCodec *codec)
82 {
83  const uint64_t *p;
84  uint64_t best_ch_layout = 0;
85  int best_nb_channels = 0;
86 
87  if (!codec->channel_layouts)
88  return AV_CH_LAYOUT_STEREO;
89 
90  p = codec->channel_layouts;
91  while (*p) {
93 
94  if (nb_channels > best_nb_channels) {
95  best_ch_layout = *p;
96  best_nb_channels = nb_channels;
97  }
98  p++;
99  }
100  return best_ch_layout;
101 }
102 
103 /*
104  * Audio encoding example
105  */
106 static void audio_encode_example(const char *filename)
107 {
108  AVCodec *codec;
109  AVCodecContext *c= NULL;
110  AVFrame *frame;
111  AVPacket pkt;
112  int i, j, k, ret, got_output;
113  int buffer_size;
114  FILE *f;
115  uint16_t *samples;
116  float t, tincr;
117 
118  printf("Audio encoding\n");
119 
120  /* find the MP2 encoder */
122  if (!codec) {
123  fprintf(stderr, "codec not found\n");
124  exit(1);
125  }
126 
127  c = avcodec_alloc_context3(codec);
128 
129  /* put sample parameters */
130  c->bit_rate = 64000;
131 
132  /* check that the encoder supports s16 pcm input */
134  if (!check_sample_fmt(codec, c->sample_fmt)) {
135  fprintf(stderr, "encoder does not support %s",
137  exit(1);
138  }
139 
140  /* select other audio parameters supported by the encoder */
141  c->sample_rate = select_sample_rate(codec);
144 
145  /* open it */
146  if (avcodec_open2(c, codec, NULL) < 0) {
147  fprintf(stderr, "could not open codec\n");
148  exit(1);
149  }
150 
151  f = fopen(filename, "wb");
152  if (!f) {
153  fprintf(stderr, "could not open %s\n", filename);
154  exit(1);
155  }
156 
157  /* frame containing input raw audio */
158  frame = av_frame_alloc();
159  if (!frame) {
160  fprintf(stderr, "could not allocate audio frame\n");
161  exit(1);
162  }
163 
164  frame->nb_samples = c->frame_size;
165  frame->format = c->sample_fmt;
166  frame->channel_layout = c->channel_layout;
167 
168  /* the codec gives us the frame size, in samples,
169  * we calculate the size of the samples buffer in bytes */
170  buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
171  c->sample_fmt, 0);
172  samples = av_malloc(buffer_size);
173  if (!samples) {
174  fprintf(stderr, "could not allocate %d bytes for samples buffer\n",
175  buffer_size);
176  exit(1);
177  }
178  /* setup the data pointers in the AVFrame */
179  ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
180  (const uint8_t*)samples, buffer_size, 0);
181  if (ret < 0) {
182  fprintf(stderr, "could not setup audio frame\n");
183  exit(1);
184  }
185 
186  /* encode a single tone sound */
187  t = 0;
188  tincr = 2 * M_PI * 440.0 / c->sample_rate;
189  for(i=0;i<200;i++) {
190  av_init_packet(&pkt);
191  pkt.data = NULL; // packet data will be allocated by the encoder
192  pkt.size = 0;
193 
194  for (j = 0; j < c->frame_size; j++) {
195  samples[2*j] = (int)(sin(t) * 10000);
196 
197  for (k = 1; k < c->channels; k++)
198  samples[2*j + k] = samples[2*j];
199  t += tincr;
200  }
201  /* encode the samples */
202  ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
203  if (ret < 0) {
204  fprintf(stderr, "error encoding audio frame\n");
205  exit(1);
206  }
207  if (got_output) {
208  fwrite(pkt.data, 1, pkt.size, f);
209  av_free_packet(&pkt);
210  }
211  }
212  fclose(f);
213 
214  av_freep(&samples);
215  av_frame_free(&frame);
216  avcodec_close(c);
217  av_free(c);
218 }
219 
220 /*
221  * Audio decoding.
222  */
223 static void audio_decode_example(const char *outfilename, const char *filename)
224 {
225  AVCodec *codec;
226  AVCodecContext *c= NULL;
227  int len;
228  FILE *f, *outfile;
230  AVPacket avpkt;
231  AVFrame *decoded_frame = NULL;
232 
233  av_init_packet(&avpkt);
234 
235  printf("Audio decoding\n");
236 
237  /* find the mpeg audio decoder */
239  if (!codec) {
240  fprintf(stderr, "codec not found\n");
241  exit(1);
242  }
243 
244  c = avcodec_alloc_context3(codec);
245 
246  /* open it */
247  if (avcodec_open2(c, codec, NULL) < 0) {
248  fprintf(stderr, "could not open codec\n");
249  exit(1);
250  }
251 
252  f = fopen(filename, "rb");
253  if (!f) {
254  fprintf(stderr, "could not open %s\n", filename);
255  exit(1);
256  }
257  outfile = fopen(outfilename, "wb");
258  if (!outfile) {
259  av_free(c);
260  exit(1);
261  }
262 
263  /* decode until eof */
264  avpkt.data = inbuf;
265  avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
266 
267  while (avpkt.size > 0) {
268  int got_frame = 0;
269 
270  if (!decoded_frame) {
271  if (!(decoded_frame = av_frame_alloc())) {
272  fprintf(stderr, "out of memory\n");
273  exit(1);
274  }
275  }
276 
277  len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
278  if (len < 0) {
279  fprintf(stderr, "Error while decoding\n");
280  exit(1);
281  }
282  if (got_frame) {
283  /* if a frame has been decoded, output it */
284  int data_size = av_samples_get_buffer_size(NULL, c->channels,
285  decoded_frame->nb_samples,
286  c->sample_fmt, 1);
287  fwrite(decoded_frame->data[0], 1, data_size, outfile);
288  }
289  avpkt.size -= len;
290  avpkt.data += len;
291  if (avpkt.size < AUDIO_REFILL_THRESH) {
292  /* Refill the input buffer, to avoid trying to decode
293  * incomplete frames. Instead of this, one could also use
294  * a parser, or use a proper container format through
295  * libavformat. */
296  memmove(inbuf, avpkt.data, avpkt.size);
297  avpkt.data = inbuf;
298  len = fread(avpkt.data + avpkt.size, 1,
299  AUDIO_INBUF_SIZE - avpkt.size, f);
300  if (len > 0)
301  avpkt.size += len;
302  }
303  }
304 
305  fclose(outfile);
306  fclose(f);
307 
308  avcodec_close(c);
309  av_free(c);
310  av_frame_free(&decoded_frame);
311 }
312 
313 /*
314  * Video encoding example
315  */
316 static void video_encode_example(const char *filename)
317 {
318  AVCodec *codec;
319  AVCodecContext *c= NULL;
320  int i, ret, x, y, got_output;
321  FILE *f;
322  AVFrame *picture;
323  AVPacket pkt;
324  uint8_t endcode[] = { 0, 0, 1, 0xb7 };
325 
326  printf("Video encoding\n");
327 
328  /* find the mpeg1 video encoder */
330  if (!codec) {
331  fprintf(stderr, "codec not found\n");
332  exit(1);
333  }
334 
335  c = avcodec_alloc_context3(codec);
336  picture = av_frame_alloc();
337 
338  /* put sample parameters */
339  c->bit_rate = 400000;
340  /* resolution must be a multiple of two */
341  c->width = 352;
342  c->height = 288;
343  /* frames per second */
344  c->time_base= (AVRational){1,25};
345  c->gop_size = 10; /* emit one intra frame every ten frames */
346  c->max_b_frames=1;
348 
349  /* open it */
350  if (avcodec_open2(c, codec, NULL) < 0) {
351  fprintf(stderr, "could not open codec\n");
352  exit(1);
353  }
354 
355  f = fopen(filename, "wb");
356  if (!f) {
357  fprintf(stderr, "could not open %s\n", filename);
358  exit(1);
359  }
360 
361  ret = av_image_alloc(picture->data, picture->linesize, c->width, c->height,
362  c->pix_fmt, 32);
363  if (ret < 0) {
364  fprintf(stderr, "could not alloc raw picture buffer\n");
365  exit(1);
366  }
367  picture->format = c->pix_fmt;
368  picture->width = c->width;
369  picture->height = c->height;
370 
371  /* encode 1 second of video */
372  for(i=0;i<25;i++) {
373  av_init_packet(&pkt);
374  pkt.data = NULL; // packet data will be allocated by the encoder
375  pkt.size = 0;
376 
377  fflush(stdout);
378  /* prepare a dummy image */
379  /* Y */
380  for(y=0;y<c->height;y++) {
381  for(x=0;x<c->width;x++) {
382  picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
383  }
384  }
385 
386  /* Cb and Cr */
387  for(y=0;y<c->height/2;y++) {
388  for(x=0;x<c->width/2;x++) {
389  picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
390  picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
391  }
392  }
393 
394  picture->pts = i;
395 
396  /* encode the image */
397  ret = avcodec_encode_video2(c, &pkt, picture, &got_output);
398  if (ret < 0) {
399  fprintf(stderr, "error encoding frame\n");
400  exit(1);
401  }
402 
403  if (got_output) {
404  printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
405  fwrite(pkt.data, 1, pkt.size, f);
406  av_free_packet(&pkt);
407  }
408  }
409 
410  /* get the delayed frames */
411  for (got_output = 1; got_output; i++) {
412  fflush(stdout);
413 
414  ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
415  if (ret < 0) {
416  fprintf(stderr, "error encoding frame\n");
417  exit(1);
418  }
419 
420  if (got_output) {
421  printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
422  fwrite(pkt.data, 1, pkt.size, f);
423  av_free_packet(&pkt);
424  }
425  }
426 
427  /* add sequence end code to have a real mpeg file */
428  fwrite(endcode, 1, sizeof(endcode), f);
429  fclose(f);
430 
431  avcodec_close(c);
432  av_free(c);
433  av_freep(&picture->data[0]);
434  av_frame_free(&picture);
435  printf("\n");
436 }
437 
438 /*
439  * Video decoding example
440  */
441 
442 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
443  char *filename)
444 {
445  FILE *f;
446  int i;
447 
448  f=fopen(filename,"w");
449  fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
450  for(i=0;i<ysize;i++)
451  fwrite(buf + i * wrap,1,xsize,f);
452  fclose(f);
453 }
454 
455 static void video_decode_example(const char *outfilename, const char *filename)
456 {
457  AVCodec *codec;
458  AVCodecContext *c= NULL;
459  int frame, got_picture, len;
460  FILE *f;
461  AVFrame *picture;
463  char buf[1024];
464  AVPacket avpkt;
465 
466  av_init_packet(&avpkt);
467 
468  /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
469  memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
470 
471  printf("Video decoding\n");
472 
473  /* find the mpeg1 video decoder */
475  if (!codec) {
476  fprintf(stderr, "codec not found\n");
477  exit(1);
478  }
479 
480  c = avcodec_alloc_context3(codec);
481  picture = av_frame_alloc();
482 
484  c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
485 
486  /* For some codecs, such as msmpeg4 and mpeg4, width and height
487  MUST be initialized there because this information is not
488  available in the bitstream. */
489 
490  /* open it */
491  if (avcodec_open2(c, codec, NULL) < 0) {
492  fprintf(stderr, "could not open codec\n");
493  exit(1);
494  }
495 
496  /* the codec gives us the frame size, in samples */
497 
498  f = fopen(filename, "rb");
499  if (!f) {
500  fprintf(stderr, "could not open %s\n", filename);
501  exit(1);
502  }
503 
504  frame = 0;
505  for(;;) {
506  avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
507  if (avpkt.size == 0)
508  break;
509 
510  /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
511  and this is the only method to use them because you cannot
512  know the compressed data size before analysing it.
513 
514  BUT some other codecs (msmpeg4, mpeg4) are inherently frame
515  based, so you must call them with all the data for one
516  frame exactly. You must also initialize 'width' and
517  'height' before initializing them. */
518 
519  /* NOTE2: some codecs allow the raw parameters (frame size,
520  sample rate) to be changed at any frame. We handle this, so
521  you should also take care of it */
522 
523  /* here, we use a stream based decoder (mpeg1video), so we
524  feed decoder and see if it could decode a frame */
525  avpkt.data = inbuf;
526  while (avpkt.size > 0) {
527  len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
528  if (len < 0) {
529  fprintf(stderr, "Error while decoding frame %d\n", frame);
530  exit(1);
531  }
532  if (got_picture) {
533  printf("saving frame %3d\n", frame);
534  fflush(stdout);
535 
536  /* the picture is allocated by the decoder. no need to
537  free it */
538  snprintf(buf, sizeof(buf), outfilename, frame);
539  pgm_save(picture->data[0], picture->linesize[0],
540  c->width, c->height, buf);
541  frame++;
542  }
543  avpkt.size -= len;
544  avpkt.data += len;
545  }
546  }
547 
548  /* some codecs, such as MPEG, transmit the I and P frame with a
549  latency of one frame. You must do the following to have a
550  chance to get the last frame of the video */
551  avpkt.data = NULL;
552  avpkt.size = 0;
553  len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
554  if (got_picture) {
555  printf("saving last frame %3d\n", frame);
556  fflush(stdout);
557 
558  /* the picture is allocated by the decoder. no need to
559  free it */
560  snprintf(buf, sizeof(buf), outfilename, frame);
561  pgm_save(picture->data[0], picture->linesize[0],
562  c->width, c->height, buf);
563  frame++;
564  }
565 
566  fclose(f);
567 
568  avcodec_close(c);
569  av_free(c);
570  av_frame_free(&picture);
571  printf("\n");
572 }
573 
574 int main(int argc, char **argv)
575 {
576  const char *filename;
577 
578  /* register all the codecs */
580 
581  if (argc <= 1) {
582  audio_encode_example("/tmp/test.mp2");
583  audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
584 
585  video_encode_example("/tmp/test.mpg");
586  filename = "/tmp/test.mpg";
587  } else {
588  filename = argv[1];
589  }
590 
591  // audio_decode_example("/tmp/test.sw", filename);
592  video_decode_example("/tmp/test%d.pgm", filename);
593 
594  return 0;
595 }
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:243
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:1761
static void video_decode_example(const char *outfilename, const char *filename)
Definition: avcodec.c:455
static void video_encode_example(const char *filename)
Definition: avcodec.c:316
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:181
#define CODEC_CAP_TRUNCATED
Definition: avcodec.h:685
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:1325
int size
Definition: avcodec.h:974
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1270
int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of audio.
Definition: utils.c:1314
#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
static void audio_decode_example(const char *outfilename, const char *filename)
Definition: avcodec.c:223
int main(int argc, char **argv)
Definition: avcodec.c:574
AVCodec.
Definition: avcodec.h:2812
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1175
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, enum AVSampleFormat sample_fmt, const uint8_t *buf, int buf_size, int align)
Fill audio frame data and linesize.
Definition: utils.c:296
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1815
uint8_t
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:57
#define AUDIO_INBUF_SIZE
Definition: avcodec.c:47
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:211
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: utils.c:1412
static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize, char *filename)
Definition: avcodec.c:442
uint8_t * data
Definition: avcodec.h:973
static int select_channel_layout(AVCodec *codec)
Definition: avcodec.c:81
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:1710
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: avcodec.h:2836
#define CODEC_FLAG_TRUNCATED
Definition: avcodec.h:646
int width
width and height of the video frame
Definition: frame.h:174
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:69
int capabilities
Codec capabilities.
Definition: avcodec.h:2831
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1144
#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
#define FFMAX(a, b)
Definition: common.h:55
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1868
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:381
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:531
int bit_rate
the average bitrate
Definition: avcodec.h:1114
audio channel layout utility functions
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:124
int width
picture width / height.
Definition: avcodec.h:1229
static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
Definition: avcodec.c:51
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:186
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1827
NULL
Definition: eval.c:55
sample_fmt
Definition: avconv_filter.c:68
Libavcodec external API header.
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:61
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:68
int sample_rate
samples per second
Definition: avcodec.h:1807
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:153
main external API structure.
Definition: avcodec.h:1050
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:1780
#define INBUF_SIZE
Definition: avcodec.c:46
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:108
rational number numerator/denominator
Definition: rational.h:43
#define AUDIO_REFILL_THRESH
Definition: avcodec.c:48
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:982
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1255
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
static int select_sample_rate(AVCodec *codec)
Definition: avcodec.c:64
common internal and external API header
signed 16 bits
Definition: samplefmt.h:64
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:47
int len
int channels
number of audio channels
Definition: avcodec.h:1808
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0 ...
Definition: avcodec.h:2834
static void audio_encode_example(const char *filename)
Definition: avcodec.c:106
int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: utils.c:1574
int height
Definition: frame.h:174
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:2835
int nb_channels
This structure stores compressed data.
Definition: avcodec.h:950
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:179
FILE * outfile
Definition: audiogen.c:96
int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: utils.c:1630