FFmpeg: doc/examples/demuxing_decoding.c Source File

FFmpeg

[フレーム]

demuxing_decoding.c

Go to the documentation of this file.

1 /*

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 */

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 */

32 #include <libavutil/imgutils.h>

33 #include <libavutil/samplefmt.h>

34 #include <libavutil/timestamp.h>

35 #include <libavformat/avformat.h>

37 static AVFormatContext *fmt_ctx = NULL;

38 static AVCodecContext *video_dec_ctx = NULL, *audio_dec_ctx;

39 static int width, height;

40 static enum AVPixelFormat pix_fmt;

41 static AVStream *video_stream = NULL, *audio_stream = NULL;

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;

48 static uint8_t *video_dst_data[4] = {NULL};

49 static int video_dst_linesize[4];

50 static int video_dst_bufsize;

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;

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;

64 static int decode_packet(int *got_frame, int cached)

65 {

66 int ret = 0;

67 int decoded = pkt.size;

69 *got_frame = 0;

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 }

79 if (*got_frame) {

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",

90 width, height, av_get_pix_fmt_name(pix_fmt),

91 frame->width, frame->height,

92 av_get_pix_fmt_name(frame->format));

93 return -1;

94 }

96 printf("video_frame%s n:%d coded_n:%d\n",

97 cached ? "(cached)" : "",

98 video_frame_count++, frame->coded_picture_number);

100 /* copy decoded frame to destination buffer:

101 * this is required since rawvideo expects non aligned data */

102 av_image_copy(video_dst_data, video_dst_linesize,

103 (const uint8_t **)(frame->data), frame->linesize,

104 pix_fmt, width, height);

105

106 /* write to rawvideo file */

107 fwrite(video_dst_data[0], 1, video_dst_bufsize, video_dst_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,

127 av_ts2timestr(frame->pts, &audio_dec_ctx->time_base));

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,

150 AVCodecContext **dec_ctx, AVFormatContext *fmt_ctx, enum AVMediaType type)

151 {

152 int ret, stream_index;

153 AVStream *st;

154 AVCodec *dec = NULL;

155 AVDictionary *opts = 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",

160 av_get_media_type_string(type), src_filename);

161 return ret;

162 } else {

163 stream_index = ret;

164 st = fmt_ctx->streams[stream_index];

165

166 /* find decoder for the stream */

167 dec = avcodec_find_decoder(st->codecpar->codec_id);

168 if (!dec) {

169 fprintf(stderr, "Failed to find %s codec\n",

170 av_get_media_type_string(type));

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",

178 av_get_media_type_string(type));

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",

185 av_get_media_type_string(type));

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",

193 av_get_media_type_string(type));

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 /* register all formats and codecs */

256 av_register_all();

257

258 /* open input file, and allocate format context */

259 if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {

260 fprintf(stderr, "Could not open source file %s\n", src_filename);

261 exit(1);

262 }

263

264 /* retrieve stream information */

265 if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {

266 fprintf(stderr, "Could not find stream information\n");

267 exit(1);

268 }

269

270 if (open_codec_context(&video_stream_idx, &video_dec_ctx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {

271 video_stream = fmt_ctx->streams[video_stream_idx];

272

273 video_dst_file = fopen(video_dst_filename, "wb");

274 if (!video_dst_file) {

275 fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);

276 ret = 1;

277 goto end;

278 }

279

280 /* allocate image where the decoded image will be put */

281 width = video_dec_ctx->width;

282 height = video_dec_ctx->height;

283 pix_fmt = video_dec_ctx->pix_fmt;

284 ret = av_image_alloc(video_dst_data, video_dst_linesize,

285 width, height, pix_fmt, 1);

286 if (ret < 0) {

287 fprintf(stderr, "Could not allocate raw video buffer\n");

288 goto end;

289 }

290 video_dst_bufsize = ret;

291 }

292

293 if (open_codec_context(&audio_stream_idx, &audio_dec_ctx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {

294 audio_stream = fmt_ctx->streams[audio_stream_idx];

295 audio_dst_file = fopen(audio_dst_filename, "wb");

296 if (!audio_dst_file) {

297 fprintf(stderr, "Could not open destination file %s\n", audio_dst_filename);

298 ret = 1;

299 goto end;

300 }

301 }

302

303 /* dump input information to stderr */

304 av_dump_format(fmt_ctx, 0, src_filename, 0);

305

306 if (!audio_stream && !video_stream) {

307 fprintf(stderr, "Could not find audio or video stream in the input, aborting\n");

308 ret = 1;

309 goto end;

310 }

311

312 frame = av_frame_alloc();

313 if (!frame) {

314 fprintf(stderr, "Could not allocate frame\n");

315 ret = AVERROR(ENOMEM);

316 goto end;

317 }

318

319 /* initialize packet, set data to NULL, let the demuxer fill it */

320 av_init_packet(&pkt);

321 pkt.data = NULL;

322 pkt.size = 0;

323

324 if (video_stream)

325 printf("Demuxing video from file '%s' into '%s'\n", src_filename, video_dst_filename);

326 if (audio_stream)

327 printf("Demuxing audio from file '%s' into '%s'\n", src_filename, audio_dst_filename);

328

329 /* read frames from the file */

330 while (av_read_frame(fmt_ctx, &pkt) >= 0) {

331 AVPacket orig_pkt = pkt;

332 do {

333 ret = decode_packet(&got_frame, 0);

334 if (ret < 0)

335 break;

336 pkt.data += ret;

337 pkt.size -= ret;

338 } while (pkt.size > 0);

339 av_packet_unref(&orig_pkt);

340 }

341

342 /* flush cached frames */

343 pkt.data = NULL;

344 pkt.size = 0;

345 do {

346 decode_packet(&got_frame, 1);

347 } while (got_frame);

348

349 printf("Demuxing succeeded.\n");

350

351 if (video_stream) {

352 printf("Play the output video file with the command:\n"

353 "ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",

354 av_get_pix_fmt_name(pix_fmt), width, height,

355 video_dst_filename);

356 }

357

358 if (audio_stream) {

359 enum AVSampleFormat sfmt = audio_dec_ctx->sample_fmt;

360 int n_channels = audio_dec_ctx->channels;

361 const char *fmt;

362

363 if (av_sample_fmt_is_planar(sfmt)) {

364 const char *packed = av_get_sample_fmt_name(sfmt);

365 printf("Warning: the sample format the decoder produced is planar "

366 "(%s). This example will output the first channel only.\n",

367 packed ? packed : "?");

368 sfmt = av_get_packed_sample_fmt(sfmt);

369 n_channels = 1;

370 }

371

372 if ((ret = get_format_from_sample_fmt(&fmt, sfmt)) < 0)

373 goto end;

374

375 printf("Play the output audio file with the command:\n"

376 "ffplay -f %s -ac %d -ar %d %s\n",

377 fmt, n_channels, audio_dec_ctx->sample_rate,

378 audio_dst_filename);

379 }

380

381 end:

382 avcodec_free_context(&video_dec_ctx);

383 avcodec_free_context(&audio_dec_ctx);

384 avformat_close_input(&fmt_ctx);

385 if (video_dst_file)

386 fclose(video_dst_file);

387 if (audio_dst_file)

388 fclose(audio_dst_file);

389 av_frame_free(&frame);

390 av_free(video_dst_data[0]);

391

392 return ret < 0;

393 }

NULL

#define NULL

Definition: coverity.c:32

decode_packet

static int decode_packet(int *got_frame, int cached)

Definition: demuxing_decoding.c:64

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demuxing_decoding.c:40

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:187

fmt

const char * fmt

Definition: avisynth_c.h:769

imgutils.h

misc image utilities

av_image_alloc

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

fmt_ctx

static AVFormatContext * fmt_ctx

Definition: demuxing_decoding.c:37

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: avcodec.h:4066

AVPacket::size

int size

Definition: avcodec.h:1658

audio_frame_count

static int audio_frame_count

Definition: demuxing_decoding.c:56

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1960

open_codec_context

static int open_codec_context(int *stream_idx, AVCodecContext **dec_ctx, AVFormatContext *fmt_ctx, enum AVMediaType type)

Definition: demuxing_decoding.c:149

video_stream

static AVStream * video_stream

Definition: demuxing_decoding.c:41

avcodec_decode_audio4

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: utils.c:2336

samplefmt.h

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

AV_SAMPLE_FMT_FLT

float

Definition: samplefmt.h:63

audio_stream_idx

static int audio_stream_idx

Definition: demuxing_decoding.c:52

AVCodec

AVCodec.

Definition: avcodec.h:3681

AVCodecContext::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...

Definition: avcodec.h:1869

AVFormatContext

Format I/O context.

Definition: avformat.h:1349

audio_dst_file

static FILE * audio_dst_file

Definition: demuxing_decoding.c:46

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:2502

uint8_t

Definition: audio_convert.c:194

AV_SAMPLE_FMT_U8

Definition: audio_convert.c:194

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:150

video_stream_idx

static int video_stream_idx

Definition: demuxing_decoding.c:52

timestamp.h

timestamp utils, mostly useful for debugging/logging purposes

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

AV_NE

#define AV_NE(be, le)

Definition: common.h:50

AVFrame::pts

int64_t pts

Presentation timestamp in time_base units (time when frame should be shown to user).

Definition: frame.h:271

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1417

avcodec_parameters_to_context

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:4264

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

AVPacket::data

uint8_t * data

Definition: avcodec.h:1657

video_dst_data

static uint8_t * video_dst_data[4]

Definition: demuxing_decoding.c:48

AV_SAMPLE_FMT_S32

signed 32 bits

Definition: samplefmt.h:62

av_sample_fmt_is_planar

int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)

Check if the sample format is planar.

Definition: samplefmt.c:112

av_dump_format

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:544

av_find_best_stream

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:3973

AVDictionary

Definition: dict.c:30

AVFrame::width

int width

width and height of the video frame

Definition: frame.h:239

video_dst_linesize

static int video_dst_linesize[4]

Definition: demuxing_decoding.c:49

audio_dst_filename

static const char * audio_dst_filename

Definition: demuxing_decoding.c:44

AVERROR

#define AVERROR(e)

Definition: error.h:43

audio_stream

static AVStream * audio_stream

Definition: demuxing_decoding.c:41

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:163

av_ts2timestr

#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

video_dec_ctx

static AVCodecContext * video_dec_ctx

Definition: demuxing_decoding.c:38

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

av_get_sample_fmt_name

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

av_image_copy

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:385

opts

AVDictionary * opts

Definition: movenc.c:50

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

avcodec_alloc_context3

AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)

Allocate an AVCodecContext and set its fields to default values.

Definition: options.c:157

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1919

av_err2str

#define av_err2str(errnum)

Convenience macro, the return value should be used only directly in function arguments but never stan...

Definition: error.h:119

refcount

static int refcount

Definition: demuxing_decoding.c:62

AV_SAMPLE_FMT_DBL

double

Definition: samplefmt.h:64

AVCodecContext::height

int height

Definition: avcodec.h:1919

video_dst_filename

static const char * video_dst_filename

Definition: demuxing_decoding.c:43

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen_template.c:36

AVStream

Stream structure.

Definition: avformat.h:889

AVFrame::format

int format

format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...

Definition: frame.h:251

AVFrame::coded_picture_number

int coded_picture_number

picture number in bitstream order

Definition: frame.h:292

avcodec_decode_video2

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: utils.c:2227

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:58

avcodec_free_context

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:172

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:2494

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:218

main

int main(int argc, char **argv)

Definition: demuxing_decoding.c:231

AVCodecContext

main external API structure.

Definition: avcodec.h:1732

avcodec_find_decoder

AVCodec * avcodec_find_decoder(enum AVCodecID id)

Find a registered decoder with a matching codec ID.

Definition: utils.c:3168

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:589

type

GLint GLenum type

Definition: opengl_enc.c:105

av_dict_set

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

get_format_from_sample_fmt

static int get_format_from_sample_fmt(const char **fmt, enum AVSampleFormat sample_fmt)

Definition: demuxing_decoding.c:202

AVMediaType

Definition: avutil.h:199

src_filename

static const char * src_filename

Definition: demuxing_decoding.c:42

avcodec_open2

int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)

Initialize the AVCodecContext to use the given AVCodec.

Definition: utils.c:1242

av_read_frame

int av_read_frame(AVFormatContext *s, AVPacket *pkt)

Return the next frame of a stream.

Definition: utils.c:1710

audio_dec_ctx

static AVCodecContext * audio_dec_ctx

Definition: demuxing_decoding.c:38

video_frame_count

static int video_frame_count

Definition: demuxing_decoding.c:55

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:498

av_get_media_type_string

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:79

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:201

av_get_bytes_per_sample

int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)

Return number of bytes per sample.

Definition: samplefmt.c:106

avformat.h

Main libavformat public API header.

av_get_packed_sample_fmt

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

avformat_find_stream_info

int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)

Read packets of a media file to get stream information.

Definition: utils.c:3374

AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:61

dec_ctx

static AVCodecContext * dec_ctx

Definition: filtering_audio.c:44

video_dst_file

static FILE * video_dst_file

Definition: demuxing_decoding.c:45

av_init_packet

void av_init_packet(AVPacket *pkt)

Initialize optional fields of a packet with default values.

Definition: avpacket.c:33

avformat_close_input

void avformat_close_input(AVFormatContext **s)

Close an opened input AVFormatContext.

Definition: utils.c:4203

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:2495

avformat_open_input

int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options)

Open an input stream and read the header.

Definition: utils.c:510

AVFrame::height

int height

Definition: frame.h:239

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

video_dst_bufsize

static int video_dst_bufsize

Definition: demuxing_decoding.c:50

AVStream::codecpar

AVCodecParameters * codecpar

Definition: avformat.h:1252

height

static int height

Definition: demuxing_decoding.c:39

av_get_pix_fmt_name

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:2249

AVPacket::stream_index

int stream_index

Definition: avcodec.h:1659

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:234

AVPixelFormat

Pixel format.

Definition: pixfmt.h:60

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1634

av_register_all

void av_register_all(void)

Initialize libavformat and register all the muxers, demuxers and protocols.

Definition: allformats.c:385

AVFrame::nb_samples

int nb_samples

number of audio samples (per channel) described by this frame

Definition: frame.h:244

width

static int width

Definition: demuxing_decoding.c:39

Generated on Fri Jan 12 2018 01:45:32 for FFmpeg by doxygen 1.8.6