FFmpeg
demuxing_decoding.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Stefano Sabatini
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  * Demuxing and decoding example.
26  *
27  * Show how to use the libavformat and libavcodec API to demux and
28  * decode audio and video data.
29  * @example demuxing_decoding.c
30  */
31 
32 #include <libavutil/imgutils.h>
33 #include <libavutil/samplefmt.h>
34 #include <libavutil/timestamp.h>
35 #include <libavformat/avformat.h>
36 
39 static int width, height;
40 static enum AVPixelFormat pix_fmt;
42 static const char *src_filename = NULL;
43 static const char *video_dst_filename = NULL;
44 static const char *audio_dst_filename = NULL;
45 static FILE *video_dst_file = NULL;
46 static FILE *audio_dst_file = NULL;
47 
48 static uint8_t *video_dst_data[4] = {NULL};
49 static int video_dst_linesize[4];
50 static int video_dst_bufsize;
51 
52 static int video_stream_idx = -1, audio_stream_idx = -1;
53 static AVFrame *frame = NULL;
54 static AVPacket pkt;
55 static int video_frame_count = 0;
56 static int audio_frame_count = 0;
57 
58 /* Enable or disable frame reference counting. You are not supposed to support
59  * both paths in your application but pick the one most appropriate to your
60  * needs. Look for the use of refcount in this example to see what are the
61  * differences of API usage between them. */
62 static int refcount = 0;
63 
64 static int decode_packet(int *got_frame, int cached)
65 {
66  int ret = 0;
67  int decoded = pkt.size;
68 
69  *got_frame = 0;
70 
71  if (pkt.stream_index == video_stream_idx) {
72  /* decode video frame */
73  ret = avcodec_decode_video2(video_dec_ctx, frame, got_frame, &pkt);
74  if (ret < 0) {
75  fprintf(stderr, "Error decoding video frame (%s)\n", av_err2str(ret));
76  return ret;
77  }
78 
79  if (*got_frame) {
80 
81  if (frame->width != width || frame->height != height ||
82  frame->format != pix_fmt) {
83  /* To handle this change, one could call av_image_alloc again and
84  * decode the following frames into another rawvideo file. */
85  fprintf(stderr, "Error: Width, height and pixel format have to be "
86  "constant in a rawvideo file, but the width, height or "
87  "pixel format of the input video changed:\n"
88  "old: width = %d, height = %d, format = %s\n"
89  "new: width = %d, height = %d, format = %s\n",
91  frame->width, frame->height,
92  av_get_pix_fmt_name(frame->format));
93  return -1;
94  }
95 
96  printf("video_frame%s n:%d coded_n:%d\n",
97  cached ? "(cached)" : "",
99 
100  /* copy decoded frame to destination buffer:
101  * this is required since rawvideo expects non aligned data */
103  (const uint8_t **)(frame->data), frame->linesize,
104  pix_fmt, width, height);
105 
106  /* write to rawvideo file */
108  }
109  } else if (pkt.stream_index == audio_stream_idx) {
110  /* decode audio frame */
111  ret = avcodec_decode_audio4(audio_dec_ctx, frame, got_frame, &pkt);
112  if (ret < 0) {
113  fprintf(stderr, "Error decoding audio frame (%s)\n", av_err2str(ret));
114  return ret;
115  }
116  /* Some audio decoders decode only part of the packet, and have to be
117  * called again with the remainder of the packet data.
118  * Sample: fate-suite/lossless-audio/luckynight-partial.shn
119  * Also, some decoders might over-read the packet. */
120  decoded = FFMIN(ret, pkt.size);
121 
122  if (*got_frame) {
123  size_t unpadded_linesize = frame->nb_samples * av_get_bytes_per_sample(frame->format);
124  printf("audio_frame%s n:%d nb_samples:%d pts:%s\n",
125  cached ? "(cached)" : "",
126  audio_frame_count++, frame->nb_samples,
128 
129  /* Write the raw audio data samples of the first plane. This works
130  * fine for packed formats (e.g. AV_SAMPLE_FMT_S16). However,
131  * most audio decoders output planar audio, which uses a separate
132  * plane of audio samples for each channel (e.g. AV_SAMPLE_FMT_S16P).
133  * In other words, this code will write only the first audio channel
134  * in these cases.
135  * You should use libswresample or libavfilter to convert the frame
136  * to packed data. */
137  fwrite(frame->extended_data[0], 1, unpadded_linesize, audio_dst_file);
138  }
139  }
140 
141  /* If we use frame reference counting, we own the data and need
142  * to de-reference it when we don't use it anymore */
143  if (*got_frame && refcount)
144  av_frame_unref(frame);
145 
146  return decoded;
147 }
148 
149 static int open_codec_context(int *stream_idx,
151 {
152  int ret, stream_index;
153  AVStream *st;
154  AVCodec *dec = NULL;
156 
157  ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
158  if (ret < 0) {
159  fprintf(stderr, "Could not find %s stream in input file '%s'\n",
161  return ret;
162  } else {
163  stream_index = ret;
164  st = fmt_ctx->streams[stream_index];
165 
166  /* find decoder for the stream */
168  if (!dec) {
169  fprintf(stderr, "Failed to find %s codec\n",
171  return AVERROR(EINVAL);
172  }
173 
174  /* Allocate a codec context for the decoder */
175  *dec_ctx = avcodec_alloc_context3(dec);
176  if (!*dec_ctx) {
177  fprintf(stderr, "Failed to allocate the %s codec context\n",
179  return AVERROR(ENOMEM);
180  }
181 
182  /* Copy codec parameters from input stream to output codec context */
183  if ((ret = avcodec_parameters_to_context(*dec_ctx, st->codecpar)) < 0) {
184  fprintf(stderr, "Failed to copy %s codec parameters to decoder context\n",
186  return ret;
187  }
188 
189  /* Init the decoders, with or without reference counting */
190  av_dict_set(&opts, "refcounted_frames", refcount ? "1" : "0", 0);
191  if ((ret = avcodec_open2(*dec_ctx, dec, &opts)) < 0) {
192  fprintf(stderr, "Failed to open %s codec\n",
194  return ret;
195  }
196  *stream_idx = stream_index;
197  }
198 
199  return 0;
200 }
201 
202 static int get_format_from_sample_fmt(const char **fmt,
203  enum AVSampleFormat sample_fmt)
204 {
205  int i;
206  struct sample_fmt_entry {
207  enum AVSampleFormat sample_fmt; const char *fmt_be, *fmt_le;
208  } sample_fmt_entries[] = {
209  { AV_SAMPLE_FMT_U8, "u8", "u8" },
210  { AV_SAMPLE_FMT_S16, "s16be", "s16le" },
211  { AV_SAMPLE_FMT_S32, "s32be", "s32le" },
212  { AV_SAMPLE_FMT_FLT, "f32be", "f32le" },
213  { AV_SAMPLE_FMT_DBL, "f64be", "f64le" },
214  };
215  *fmt = NULL;
216 
217  for (i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) {
218  struct sample_fmt_entry *entry = &sample_fmt_entries[i];
219  if (sample_fmt == entry->sample_fmt) {
220  *fmt = AV_NE(entry->fmt_be, entry->fmt_le);
221  return 0;
222  }
223  }
224 
225  fprintf(stderr,
226  "sample format %s is not supported as output format\n",
227  av_get_sample_fmt_name(sample_fmt));
228  return -1;
229 }
230 
231 int main (int argc, char **argv)
232 {
233  int ret = 0, got_frame;
234 
235  if (argc != 4 && argc != 5) {
236  fprintf(stderr, "usage: %s [-refcount] input_file video_output_file audio_output_file\n"
237  "API example program to show how to read frames from an input file.\n"
238  "This program reads frames from a file, decodes them, and writes decoded\n"
239  "video frames to a rawvideo file named video_output_file, and decoded\n"
240  "audio frames to a rawaudio file named audio_output_file.\n\n"
241  "If the -refcount option is specified, the program use the\n"
242  "reference counting frame system which allows keeping a copy of\n"
243  "the data for longer than one decode call.\n"
244  "\n", argv[0]);
245  exit(1);
246  }
247  if (argc == 5 && !strcmp(argv[1], "-refcount")) {
248  refcount = 1;
249  argv++;
250  }
251  src_filename = argv[1];
252  video_dst_filename = argv[2];
253  audio_dst_filename = argv[3];
254 
255  /* open input file, and allocate format context */
256  if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
257  fprintf(stderr, "Could not open source file %s\n", src_filename);
258  exit(1);
259  }
260 
261  /* retrieve stream information */
262  if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
263  fprintf(stderr, "Could not find stream information\n");
264  exit(1);
265  }
266 
267  if (open_codec_context(&video_stream_idx, &video_dec_ctx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
268  video_stream = fmt_ctx->streams[video_stream_idx];
269 
270  video_dst_file = fopen(video_dst_filename, "wb");
271  if (!video_dst_file) {
272  fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
273  ret = 1;
274  goto end;
275  }
276 
277  /* allocate image where the decoded image will be put */
278  width = video_dec_ctx->width;
279  height = video_dec_ctx->height;
280  pix_fmt = video_dec_ctx->pix_fmt;
282  width, height, pix_fmt, 1);
283  if (ret < 0) {
284  fprintf(stderr, "Could not allocate raw video buffer\n");
285  goto end;
286  }
288  }
289 
292  audio_dst_file = fopen(audio_dst_filename, "wb");
293  if (!audio_dst_file) {
294  fprintf(stderr, "Could not open destination file %s\n", audio_dst_filename);
295  ret = 1;
296  goto end;
297  }
298  }
299 
300  /* dump input information to stderr */
301  av_dump_format(fmt_ctx, 0, src_filename, 0);
302 
303  if (!audio_stream && !video_stream) {
304  fprintf(stderr, "Could not find audio or video stream in the input, aborting\n");
305  ret = 1;
306  goto end;
307  }
308 
309  frame = av_frame_alloc();
310  if (!frame) {
311  fprintf(stderr, "Could not allocate frame\n");
312  ret = AVERROR(ENOMEM);
313  goto end;
314  }
315 
316  /* initialize packet, set data to NULL, let the demuxer fill it */
317  av_init_packet(&pkt);
318  pkt.data = NULL;
319  pkt.size = 0;
320 
321  if (video_stream)
322  printf("Demuxing video from file '%s' into '%s'\n", src_filename, video_dst_filename);
323  if (audio_stream)
324  printf("Demuxing audio from file '%s' into '%s'\n", src_filename, audio_dst_filename);
325 
326  /* read frames from the file */
327  while (av_read_frame(fmt_ctx, &pkt) >= 0) {
328  AVPacket orig_pkt = pkt;
329  do {
330  ret = decode_packet(&got_frame, 0);
331  if (ret < 0)
332  break;
333  pkt.data += ret;
334  pkt.size -= ret;
335  } while (pkt.size > 0);
336  av_packet_unref(&orig_pkt);
337  }
338 
339  /* flush cached frames */
340  pkt.data = NULL;
341  pkt.size = 0;
342  do {
343  decode_packet(&got_frame, 1);
344  } while (got_frame);
345 
346  printf("Demuxing succeeded.\n");
347 
348  if (video_stream) {
349  printf("Play the output video file with the command:\n"
350  "ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",
353  }
354 
355  if (audio_stream) {
357  int n_channels = audio_dec_ctx->channels;
358  const char *fmt;
359 
360  if (av_sample_fmt_is_planar(sfmt)) {
361  const char *packed = av_get_sample_fmt_name(sfmt);
362  printf("Warning: the sample format the decoder produced is planar "
363  "(%s). This example will output the first channel only.\n",
364  packed ? packed : "?");
365  sfmt = av_get_packed_sample_fmt(sfmt);
366  n_channels = 1;
367  }
368 
369  if ((ret = get_format_from_sample_fmt(&fmt, sfmt)) < 0)
370  goto end;
371 
372  printf("Play the output audio file with the command:\n"
373  "ffplay -f %s -ac %d -ar %d %s\n",
374  fmt, n_channels, audio_dec_ctx->sample_rate,
376  }
377 
378 end:
379  avcodec_free_context(&video_dec_ctx);
381  avformat_close_input(&fmt_ctx);
382  if (video_dst_file)
383  fclose(video_dst_file);
384  if (audio_dst_file)
385  fclose(audio_dst_file);
386  av_frame_free(&frame);
388 
389  return ret < 0;
390 }
#define NULL
Definition: coverity.c:32
static int decode_packet(int *got_frame, int cached)
static enum AVPixelFormat pix_fmt
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
const char * fmt
Definition: avisynth_c.h:861
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
static AVFormatContext * fmt_ctx
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
int size
Definition: avcodec.h:1478
static int audio_frame_count
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
static int open_codec_context(int *stream_idx, AVCodecContext **dec_ctx, AVFormatContext *fmt_ctx, enum AVMediaType type)
static AVStream * video_stream
attribute_deprecated 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: decode.c:904
GLint GLenum type
Definition: opengl_enc.c:104
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:537
static AVPacket pkt
static int audio_stream_idx
AVCodec.
Definition: avcodec.h:3481
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1688
Format I/O context.
Definition: avformat.h:1358
static FILE * audio_dst_file
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
uint8_t
AV_SAMPLE_FMT_U8
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
static int video_stream_idx
timestamp utils, mostly useful for debugging/logging purposes
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
#define AV_NE(be, le)
Definition: common.h:50
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2096
static AVFrame * frame
uint8_t * data
Definition: avcodec.h:1477
static uint8_t * video_dst_data[4]
signed 32 bits
Definition: samplefmt.h:62
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:575
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:4192
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
static int video_dst_linesize[4]
static const char * audio_dst_filename
static AVStream * audio_stream
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:76
static AVCodecContext * video_dec_ctx
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:49
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
Definition: imgutils.c:387
AVDictionary * opts
Definition: movenc.c:50
#define FFMIN(a, b)
Definition: common.h:96
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:156
int width
picture width / height.
Definition: avcodec.h:1738
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
static int refcount
static const char * video_dst_filename
#define FF_ARRAY_ELEMS(a)
Stream structure.
Definition: avformat.h:881
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
int coded_picture_number
picture number in bitstream order
Definition: frame.h:409
attribute_deprecated 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: decode.c:897
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
Definition: options.c:171
int sample_rate
samples per second
Definition: avcodec.h:2225
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
int main(int argc, char **argv)
main external API structure.
Definition: avcodec.h:1565
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:892
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
static int get_format_from_sample_fmt(const char **fmt, enum AVSampleFormat sample_fmt)
AVMediaType
Definition: avutil.h:199
static const char * src_filename
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:542
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1768
static AVCodecContext * audio_dec_ctx
static int video_frame_count
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:76
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
Main libavformat public API header.
enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
Get the packed alternative form of the given sample format.
Definition: samplefmt.c:75
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3573
signed 16 bits
Definition: samplefmt.h:61
static AVCodecContext * dec_ctx
static FILE * video_dst_file
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4437
#define av_free(p)
int channels
number of audio channels
Definition: avcodec.h:2226
printf("static const uint8_t my_array[100] = {\n")
int height
Definition: frame.h:353
static int video_dst_bufsize
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
static int height
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2438
int stream_index
Definition: avcodec.h:1479
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
static int width