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
36
47
51
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. */
63
65 {
66 int ret = 0;
67 int decoded = pkt.
size;
68
69 *got_frame = 0;
70
72 /* decode video frame */
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
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",
93 return -1;
94 }
95
96 printf("video_frame%s n:%d coded_n:%d pts:%s\n",
97 cached ? "(cached)" : "",
100
101 /* copy decoded frame to destination buffer:
102 * this is required since rawvideo expects non aligned data */
106
107 /* write to rawvideo file */
109 }
111 /* decode audio frame */
113 if (ret < 0) {
114 fprintf(stderr,
"Error decoding audio frame (%s)\n",
av_err2str(ret));
115 return ret;
116 }
117 /* Some audio decoders decode only part of the packet, and have to be
118 * called again with the remainder of the packet data.
119 * Sample: fate-suite/lossless-audio/luckynight-partial.shn
120 * Also, some decoders might over-read the packet. */
122
123 if (*got_frame) {
125 printf("audio_frame%s n:%d nb_samples:%d pts:%s\n",
126 cached ? "(cached)" : "",
129
130 /* Write the raw audio data samples of the first plane. This works
131 * fine for packed formats (e.g. AV_SAMPLE_FMT_S16). However,
132 * most audio decoders output planar audio, which uses a separate
133 * plane of audio samples for each channel (e.g. AV_SAMPLE_FMT_S16P).
134 * In other words, this code will write only the first audio channel
135 * in these cases.
136 * You should use libswresample or libavfilter to convert the frame
137 * to packed data. */
139 }
140 }
141
142 /* If we use frame reference counting, we own the data and need
143 * to de-reference it when we don't use it anymore */
146
147 return decoded;
148 }
149
152 {
153 int ret, stream_index;
158
160 if (ret < 0) {
161 fprintf(stderr, "Could not find %s stream in input file '%s'\n",
163 return ret;
164 } else {
165 stream_index = ret;
166 st = fmt_ctx->
streams[stream_index];
167
168 /* find decoder for the stream */
171 if (!dec) {
172 fprintf(stderr, "Failed to find %s codec\n",
175 }
176
177 /* Init the decoders, with or without reference counting */
180 fprintf(stderr, "Failed to open %s codec\n",
182 return ret;
183 }
184 *stream_idx = stream_index;
185 }
186
187 return 0;
188 }
189
192 {
193 int i;
194 struct sample_fmt_entry {
196 } sample_fmt_entries[] = {
202 };
204
206 struct sample_fmt_entry *entry = &sample_fmt_entries[i];
207 if (sample_fmt == entry->sample_fmt) {
208 *fmt =
AV_NE(entry->fmt_be, entry->fmt_le);
209 return 0;
210 }
211 }
212
213 fprintf(stderr,
214 "sample format %s is not supported as output format\n",
216 return -1;
217 }
218
219 int main (
int argc,
char **argv)
220 {
221 int ret = 0, got_frame;
222
223 if (argc != 4 && argc != 5) {
224 fprintf(stderr, "usage: %s [-refcount] input_file video_output_file audio_output_file\n"
225 "API example program to show how to read frames from an input file.\n"
226 "This program reads frames from a file, decodes them, and writes decoded\n"
227 "video frames to a rawvideo file named video_output_file, and decoded\n"
228 "audio frames to a rawaudio file named audio_output_file.\n\n"
229 "If the -refcount option is specified, the program use the\n"
230 "reference counting frame system which allows keeping a copy of\n"
231 "the data for longer than one decode call.\n"
232 "\n", argv[0]);
233 exit(1);
234 }
235 if (argc == 5 && !strcmp(argv[1], "-refcount")) {
237 argv++;
238 }
242
243 /* register all formats and codecs */
245
246 /* open input file, and allocate format context */
248 fprintf(stderr,
"Could not open source file %s\n",
src_filename);
249 exit(1);
250 }
251
252 /* retrieve stream information */
254 fprintf(stderr, "Could not find stream information\n");
255 exit(1);
256 }
257
260 video_dec_ctx = video_stream->
codec;
261
265 ret = 1;
267 }
268
269 /* allocate image where the decoded image will be put */
275 if (ret < 0) {
276 fprintf(stderr, "Could not allocate raw video buffer\n");
278 }
280 }
281
288 ret = 1;
290 }
291 }
292
293 /* dump input information to stderr */
295
297 fprintf(stderr, "Could not find audio or video stream in the input, aborting\n");
298 ret = 1;
300 }
301
303 if (!frame) {
304 fprintf(stderr, "Could not allocate frame\n");
307 }
308
309 /* initialize packet, set data to NULL, let the demuxer fill it */
313
314 if (video_stream)
318
319 /* read frames from the file */
322 do {
324 if (ret < 0)
325 break;
328 }
while (pkt.
size > 0);
330 }
331
332 /* flush cached frames */
335 do {
337 } while (got_frame);
338
339 printf("Demuxing succeeded.\n");
340
341 if (video_stream) {
342 printf("Play the output video file with the command:\n"
343 "ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",
346 }
347
352
355 printf("Warning: the sample format the decoder produced is planar "
356 "(%s). This example will output the first channel only.\n",
357 packed ? packed : "?");
359 n_channels = 1;
360 }
361
364
365 printf("Play the output audio file with the command:\n"
366 "ffplay -f %s -ac %d -ar %d %s\n",
369 }
370
381
382 return ret < 0;
383 }
static int decode_packet(int *got_frame, int cached)
static enum AVPixelFormat pix_fmt
This structure describes decoded (raw) audio or video data.
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...
static AVFormatContext * fmt_ctx
static int audio_frame_count
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static AVStream * video_stream
static int audio_stream_idx
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
static FILE * audio_dst_file
enum AVSampleFormat sample_fmt
audio sample format
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static int video_stream_idx
timestamp utils, mostly useful for debugging/logging purposes
static av_cold int end(AVCodecContext *avctx)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
AVStream ** streams
A list of all streams in the file.
static uint8_t * video_dst_data[4]
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
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.
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.
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
int width
width and height of the video frame
static int video_dst_linesize[4]
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.
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.
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
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.
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.
AVCodecContext * codec
Codec context associated with this stream.
int width
picture width / height.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
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.
static const char * video_dst_filename
#define FF_ARRAY_ELEMS(a)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
int coded_picture_number
picture number in bitstream order
AVSampleFormat
Audio sample formats.
int sample_rate
samples per second
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
int main(int argc, char **argv)
main external API structure.
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
static int get_format_from_sample_fmt(const char **fmt, enum AVSampleFormat sample_fmt)
static const char * src_filename
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
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.
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.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
Get the packed alternative form of the given sample format.
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
static AVCodecContext * dec_ctx
static FILE * video_dst_file
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
static int open_codec_context(int *stream_idx, AVFormatContext *fmt_ctx, enum AVMediaType type)
int channels
number of audio channels
int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
static int video_dst_bufsize
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.
uint8_t ** extended_data
pointers to the data planes/channels.
AVPixelFormat
Pixel format.
This structure stores compressed data.
void av_register_all(void)
Initialize libavformat and register all the muxers, demuxers and protocols.
int nb_samples
number of audio samples (per channel) described by this frame