api-example.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_channells = 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_channells) {
95  best_ch_layout = *p;
96  best_nb_channells = 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 = avcodec_alloc_frame();
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  avcodec_free_frame(&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 = avcodec_alloc_frame())) {
272  fprintf(stderr, "out of memory\n");
273  exit(1);
274  }
275  } else
276  avcodec_get_frame_defaults(decoded_frame);
277 
278  len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
279  if (len < 0) {
280  fprintf(stderr, "Error while decoding\n");
281  exit(1);
282  }
283  if (got_frame) {
284  /* if a frame has been decoded, output it */
285  int data_size = av_samples_get_buffer_size(NULL, c->channels,
286  decoded_frame->nb_samples,
287  c->sample_fmt, 1);
288  fwrite(decoded_frame->data[0], 1, data_size, outfile);
289  }
290  avpkt.size -= len;
291  avpkt.data += len;
292  if (avpkt.size < AUDIO_REFILL_THRESH) {
293  /* Refill the input buffer, to avoid trying to decode
294  * incomplete frames. Instead of this, one could also use
295  * a parser, or use a proper container format through
296  * libavformat. */
297  memmove(inbuf, avpkt.data, avpkt.size);
298  avpkt.data = inbuf;
299  len = fread(avpkt.data + avpkt.size, 1,
300  AUDIO_INBUF_SIZE - avpkt.size, f);
301  if (len > 0)
302  avpkt.size += len;
303  }
304  }
305 
306  fclose(outfile);
307  fclose(f);
308 
309  avcodec_close(c);
310  av_free(c);
311  avcodec_free_frame(&decoded_frame);
312 }
313 
314 /*
315  * Video encoding example
316  */
317 static void video_encode_example(const char *filename)
318 {
319  AVCodec *codec;
320  AVCodecContext *c= NULL;
321  int i, ret, x, y, got_output;
322  FILE *f;
323  AVFrame *picture;
324  AVPacket pkt;
325  uint8_t endcode[] = { 0, 0, 1, 0xb7 };
326 
327  printf("Video encoding\n");
328 
329  /* find the mpeg1 video encoder */
331  if (!codec) {
332  fprintf(stderr, "codec not found\n");
333  exit(1);
334  }
335 
336  c = avcodec_alloc_context3(codec);
337  picture= avcodec_alloc_frame();
338 
339  /* put sample parameters */
340  c->bit_rate = 400000;
341  /* resolution must be a multiple of two */
342  c->width = 352;
343  c->height = 288;
344  /* frames per second */
345  c->time_base= (AVRational){1,25};
346  c->gop_size = 10; /* emit one intra frame every ten frames */
347  c->max_b_frames=1;
349 
350  /* open it */
351  if (avcodec_open2(c, codec, NULL) < 0) {
352  fprintf(stderr, "could not open codec\n");
353  exit(1);
354  }
355 
356  f = fopen(filename, "wb");
357  if (!f) {
358  fprintf(stderr, "could not open %s\n", filename);
359  exit(1);
360  }
361 
362  ret = av_image_alloc(picture->data, picture->linesize, c->width, c->height,
363  c->pix_fmt, 32);
364  if (ret < 0) {
365  fprintf(stderr, "could not alloc raw picture buffer\n");
366  exit(1);
367  }
368  picture->format = c->pix_fmt;
369  picture->width = c->width;
370  picture->height = c->height;
371 
372  /* encode 1 second of video */
373  for(i=0;i<25;i++) {
374  av_init_packet(&pkt);
375  pkt.data = NULL; // packet data will be allocated by the encoder
376  pkt.size = 0;
377 
378  fflush(stdout);
379  /* prepare a dummy image */
380  /* Y */
381  for(y=0;y<c->height;y++) {
382  for(x=0;x<c->width;x++) {
383  picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
384  }
385  }
386 
387  /* Cb and Cr */
388  for(y=0;y<c->height/2;y++) {
389  for(x=0;x<c->width/2;x++) {
390  picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
391  picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
392  }
393  }
394 
395  picture->pts = i;
396 
397  /* encode the image */
398  ret = avcodec_encode_video2(c, &pkt, picture, &got_output);
399  if (ret < 0) {
400  fprintf(stderr, "error encoding frame\n");
401  exit(1);
402  }
403 
404  if (got_output) {
405  printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
406  fwrite(pkt.data, 1, pkt.size, f);
407  av_free_packet(&pkt);
408  }
409  }
410 
411  /* get the delayed frames */
412  for (got_output = 1; got_output; i++) {
413  fflush(stdout);
414 
415  ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
416  if (ret < 0) {
417  fprintf(stderr, "error encoding frame\n");
418  exit(1);
419  }
420 
421  if (got_output) {
422  printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
423  fwrite(pkt.data, 1, pkt.size, f);
424  av_free_packet(&pkt);
425  }
426  }
427 
428  /* add sequence end code to have a real mpeg file */
429  fwrite(endcode, 1, sizeof(endcode), f);
430  fclose(f);
431 
432  avcodec_close(c);
433  av_free(c);
434  av_freep(&picture->data[0]);
435  avcodec_free_frame(&picture);
436  printf("\n");
437 }
438 
439 /*
440  * Video decoding example
441  */
442 
443 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
444  char *filename)
445 {
446  FILE *f;
447  int i;
448 
449  f=fopen(filename,"w");
450  fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
451  for(i=0;i<ysize;i++)
452  fwrite(buf + i * wrap,1,xsize,f);
453  fclose(f);
454 }
455 
456 static void video_decode_example(const char *outfilename, const char *filename)
457 {
458  AVCodec *codec;
459  AVCodecContext *c= NULL;
460  int frame, got_picture, len;
461  FILE *f;
462  AVFrame *picture;
464  char buf[1024];
465  AVPacket avpkt;
466 
467  av_init_packet(&avpkt);
468 
469  /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
470  memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
471 
472  printf("Video decoding\n");
473 
474  /* find the mpeg1 video decoder */
476  if (!codec) {
477  fprintf(stderr, "codec not found\n");
478  exit(1);
479  }
480 
481  c = avcodec_alloc_context3(codec);
482  picture= avcodec_alloc_frame();
483 
485  c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
486 
487  /* For some codecs, such as msmpeg4 and mpeg4, width and height
488  MUST be initialized there because this information is not
489  available in the bitstream. */
490 
491  /* open it */
492  if (avcodec_open2(c, codec, NULL) < 0) {
493  fprintf(stderr, "could not open codec\n");
494  exit(1);
495  }
496 
497  /* the codec gives us the frame size, in samples */
498 
499  f = fopen(filename, "rb");
500  if (!f) {
501  fprintf(stderr, "could not open %s\n", filename);
502  exit(1);
503  }
504 
505  frame = 0;
506  for(;;) {
507  avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
508  if (avpkt.size == 0)
509  break;
510 
511  /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
512  and this is the only method to use them because you cannot
513  know the compressed data size before analysing it.
514 
515  BUT some other codecs (msmpeg4, mpeg4) are inherently frame
516  based, so you must call them with all the data for one
517  frame exactly. You must also initialize 'width' and
518  'height' before initializing them. */
519 
520  /* NOTE2: some codecs allow the raw parameters (frame size,
521  sample rate) to be changed at any frame. We handle this, so
522  you should also take care of it */
523 
524  /* here, we use a stream based decoder (mpeg1video), so we
525  feed decoder and see if it could decode a frame */
526  avpkt.data = inbuf;
527  while (avpkt.size > 0) {
528  len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
529  if (len < 0) {
530  fprintf(stderr, "Error while decoding frame %d\n", frame);
531  exit(1);
532  }
533  if (got_picture) {
534  printf("saving frame %3d\n", frame);
535  fflush(stdout);
536 
537  /* the picture is allocated by the decoder. no need to
538  free it */
539  snprintf(buf, sizeof(buf), outfilename, frame);
540  pgm_save(picture->data[0], picture->linesize[0],
541  c->width, c->height, buf);
542  frame++;
543  }
544  avpkt.size -= len;
545  avpkt.data += len;
546  }
547  }
548 
549  /* some codecs, such as MPEG, transmit the I and P frame with a
550  latency of one frame. You must do the following to have a
551  chance to get the last frame of the video */
552  avpkt.data = NULL;
553  avpkt.size = 0;
554  len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
555  if (got_picture) {
556  printf("saving last frame %3d\n", frame);
557  fflush(stdout);
558 
559  /* the picture is allocated by the decoder. no need to
560  free it */
561  snprintf(buf, sizeof(buf), outfilename, frame);
562  pgm_save(picture->data[0], picture->linesize[0],
563  c->width, c->height, buf);
564  frame++;
565  }
566 
567  fclose(f);
568 
569  avcodec_close(c);
570  av_free(c);
571  avcodec_free_frame(&picture);
572  printf("\n");
573 }
574 
575 int main(int argc, char **argv)
576 {
577  const char *filename;
578 
579  /* register all the codecs */
581 
582  if (argc <= 1) {
583  audio_encode_example("/tmp/test.mp2");
584  audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
585 
586  video_encode_example("/tmp/test.mpg");
587  filename = "/tmp/test.mpg";
588  } else {
589  filename = argv[1];
590  }
591 
592  // audio_decode_example("/tmp/test.sw", filename);
593  video_decode_example("/tmp/test%d.pgm", filename);
594 
595  return 0;
596 }
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:61
static int16_t * samples
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:153
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:1496
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
static int select_channel_layout(AVCodec *codec)
Definition: api-example.c:81
static void audio_decode_example(const char *outfilename, const char *filename)
Definition: api-example.c:223
misc image utilities
static float tincr
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:179
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:1588
int main(int argc, char **argv)
Definition: api-example.c:575
#define INBUF_SIZE
Definition: api-example.c:46
int size
Definition: avcodec.h:916
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1533
#define wrap(func)
Definition: w64xmmtest.h:70
int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of audio.
Definition: utils.c:946
#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:67
signed 16 bits
Definition: samplefmt.h:52
AVCodec.
Definition: avcodec.h:2960
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1465
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:151
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:264
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
uint8_t
int64_t pts
presentation timestamp in time_base units (time when frame should be shown to user) If AV_NOPTS_VALUE...
Definition: avcodec.h:1088
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: utils.c:1166
uint8_t * data
Definition: avcodec.h:915
static float t
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:1437
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: avcodec.h:2984
int width
width and height of the video frame
Definition: avcodec.h:1035
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:139
int capabilities
Codec capabilities.
Definition: avcodec.h:2979
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:1434
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2165
uint64_t channel_layout
Channel layout of the audio data.
Definition: avcodec.h:1318
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
Definition: utils.c:618
struct AVRational AVRational
rational number numerator/denominator
int bit_rate
the average bitrate
Definition: avcodec.h:1404
static AVFrame * picture
audio channel layout utility functions
static void audio_encode_example(const char *filename)
Definition: api-example.c:106
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:126
int width
picture width / height.
Definition: avcodec.h:1508
static void video_decode_example(const char *outfilename, const char *filename)
Definition: api-example.c:456
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
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: avcodec.h:1051
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2124
NULL
Definition: eval.c:52
sample_fmt
Definition: avconv_filter.c:63
external API header
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:63
int sample_rate
samples per second
Definition: avcodec.h:2104
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
main external API structure.
Definition: avcodec.h:1339
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:1515
static void video_encode_example(const char *filename)
Definition: api-example.c:317
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:604
static int select_sample_rate(AVCodec *codec)
Definition: api-example.c:64
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:645
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1524
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
common internal and external API header
static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
Definition: api-example.c:51
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:42
#define AUDIO_REFILL_THRESH
Definition: api-example.c:48
#define AUDIO_INBUF_SIZE
Definition: api-example.c:47
int len
int channels
number of audio channels
Definition: avcodec.h:2105
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0 ...
Definition: avcodec.h:2982
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:1268
void avcodec_free_frame(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: utils.c:630
int height
Definition: avcodec.h:1035
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:2983
int nb_channels
static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize, char *filename)
Definition: api-example.c:443
This structure stores compressed data.
Definition: avcodec.h:898
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042
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:1362