avformat: Remove non-compiling and/or silly commented-out printf/av_log statements
[libav.git] / libavformat / output-example.c
1 /*
2 * Copyright (c) 2003 Fabrice Bellard
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 * libavformat API example.
26 *
27 * @example libavformat/output-example.c
28 * Output a media file in any supported libavformat format.
29 * The default codecs are used.
30 */
31
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <math.h>
36
37 #include "libavutil/mathematics.h"
38 #include "libavformat/avformat.h"
39 #include "libswscale/swscale.h"
40
41 #undef exit
42
43 /* 5 seconds stream duration */
44 #define STREAM_DURATION 5.0
45 #define STREAM_FRAME_RATE 25 /* 25 images/s */
46 #define STREAM_NB_FRAMES ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
47 #define STREAM_PIX_FMT PIX_FMT_YUV420P /* default pix_fmt */
48
49 static int sws_flags = SWS_BICUBIC;
50
51 /**************************************************************/
52 /* audio output */
53
54 static float t, tincr, tincr2;
55 static int16_t *samples;
56 static int audio_input_frame_size;
57
58 /*
59 * add an audio output stream
60 */
61 static AVStream *add_audio_stream(AVFormatContext *oc, enum AVCodecID codec_id)
62 {
63 AVCodecContext *c;
64 AVStream *st;
65 AVCodec *codec;
66
67 /* find the audio encoder */
68 codec = avcodec_find_encoder(codec_id);
69 if (!codec) {
70 fprintf(stderr, "codec not found\n");
71 exit(1);
72 }
73
74 st = avformat_new_stream(oc, codec);
75 if (!st) {
76 fprintf(stderr, "Could not alloc stream\n");
77 exit(1);
78 }
79
80 c = st->codec;
81
82 /* put sample parameters */
83 c->sample_fmt = AV_SAMPLE_FMT_S16;
84 c->bit_rate = 64000;
85 c->sample_rate = 44100;
86 c->channels = 2;
87
88 // some formats want stream headers to be separate
89 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
90 c->flags |= CODEC_FLAG_GLOBAL_HEADER;
91
92 return st;
93 }
94
95 static void open_audio(AVFormatContext *oc, AVStream *st)
96 {
97 AVCodecContext *c;
98
99 c = st->codec;
100
101 /* open it */
102 if (avcodec_open2(c, NULL, NULL) < 0) {
103 fprintf(stderr, "could not open codec\n");
104 exit(1);
105 }
106
107 /* init signal generator */
108 t = 0;
109 tincr = 2 * M_PI * 110.0 / c->sample_rate;
110 /* increment frequency by 110 Hz per second */
111 tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
112
113 if (c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)
114 audio_input_frame_size = 10000;
115 else
116 audio_input_frame_size = c->frame_size;
117 samples = av_malloc(audio_input_frame_size *
118 av_get_bytes_per_sample(c->sample_fmt) *
119 c->channels);
120 }
121
122 /* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
123 * 'nb_channels' channels. */
124 static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
125 {
126 int j, i, v;
127 int16_t *q;
128
129 q = samples;
130 for (j = 0; j < frame_size; j++) {
131 v = (int)(sin(t) * 10000);
132 for (i = 0; i < nb_channels; i++)
133 *q++ = v;
134 t += tincr;
135 tincr += tincr2;
136 }
137 }
138
139 static void write_audio_frame(AVFormatContext *oc, AVStream *st)
140 {
141 AVCodecContext *c;
142 AVPacket pkt = { 0 }; // data and size must be 0;
143 AVFrame *frame = avcodec_alloc_frame();
144 int got_packet;
145
146 av_init_packet(&pkt);
147 c = st->codec;
148
149 get_audio_frame(samples, audio_input_frame_size, c->channels);
150 frame->nb_samples = audio_input_frame_size;
151 avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
152 (uint8_t *)samples,
153 audio_input_frame_size *
154 av_get_bytes_per_sample(c->sample_fmt) *
155 c->channels, 1);
156
157 avcodec_encode_audio2(c, &pkt, frame, &got_packet);
158 if (!got_packet)
159 return;
160
161 pkt.stream_index = st->index;
162
163 /* Write the compressed frame to the media file. */
164 if (av_interleaved_write_frame(oc, &pkt) != 0) {
165 fprintf(stderr, "Error while writing audio frame\n");
166 exit(1);
167 }
168 avcodec_free_frame(&frame);
169 }
170
171 static void close_audio(AVFormatContext *oc, AVStream *st)
172 {
173 avcodec_close(st->codec);
174
175 av_free(samples);
176 }
177
178 /**************************************************************/
179 /* video output */
180
181 static AVFrame *picture, *tmp_picture;
182 static uint8_t *video_outbuf;
183 static int frame_count, video_outbuf_size;
184
185 /* Add a video output stream. */
186 static AVStream *add_video_stream(AVFormatContext *oc, enum AVCodecID codec_id)
187 {
188 AVCodecContext *c;
189 AVStream *st;
190 AVCodec *codec;
191
192 /* find the video encoder */
193 codec = avcodec_find_encoder(codec_id);
194 if (!codec) {
195 fprintf(stderr, "codec not found\n");
196 exit(1);
197 }
198
199 st = avformat_new_stream(oc, codec);
200 if (!st) {
201 fprintf(stderr, "Could not alloc stream\n");
202 exit(1);
203 }
204
205 c = st->codec;
206
207 /* Put sample parameters. */
208 c->bit_rate = 400000;
209 /* Resolution must be a multiple of two. */
210 c->width = 352;
211 c->height = 288;
212 /* timebase: This is the fundamental unit of time (in seconds) in terms
213 * of which frame timestamps are represented. For fixed-fps content,
214 * timebase should be 1/framerate and timestamp increments should be
215 * identical to 1. */
216 c->time_base.den = STREAM_FRAME_RATE;
217 c->time_base.num = 1;
218 c->gop_size = 12; /* emit one intra frame every twelve frames at most */
219 c->pix_fmt = STREAM_PIX_FMT;
220 if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
221 /* just for testing, we also add B frames */
222 c->max_b_frames = 2;
223 }
224 if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
225 /* Needed to avoid using macroblocks in which some coeffs overflow.
226 * This does not happen with normal video, it just happens here as
227 * the motion of the chroma plane does not match the luma plane. */
228 c->mb_decision = 2;
229 }
230 /* Some formats want stream headers to be separate. */
231 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
232 c->flags |= CODEC_FLAG_GLOBAL_HEADER;
233
234 return st;
235 }
236
237 static AVFrame *alloc_picture(enum PixelFormat pix_fmt, int width, int height)
238 {
239 AVFrame *picture;
240 uint8_t *picture_buf;
241 int size;
242
243 picture = avcodec_alloc_frame();
244 if (!picture)
245 return NULL;
246 size = avpicture_get_size(pix_fmt, width, height);
247 picture_buf = av_malloc(size);
248 if (!picture_buf) {
249 av_free(picture);
250 return NULL;
251 }
252 avpicture_fill((AVPicture *)picture, picture_buf,
253 pix_fmt, width, height);
254 return picture;
255 }
256
257 static void open_video(AVFormatContext *oc, AVStream *st)
258 {
259 AVCodecContext *c;
260
261 c = st->codec;
262
263 /* open the codec */
264 if (avcodec_open2(c, NULL, NULL) < 0) {
265 fprintf(stderr, "could not open codec\n");
266 exit(1);
267 }
268
269 video_outbuf = NULL;
270 if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
271 /* Allocate output buffer. */
272 /* XXX: API change will be done. */
273 /* Buffers passed into lav* can be allocated any way you prefer,
274 * as long as they're aligned enough for the architecture, and
275 * they're freed appropriately (such as using av_free for buffers
276 * allocated with av_malloc). */
277 video_outbuf_size = 200000;
278 video_outbuf = av_malloc(video_outbuf_size);
279 }
280
281 /* Allocate the encoded raw picture. */
282 picture = alloc_picture(c->pix_fmt, c->width, c->height);
283 if (!picture) {
284 fprintf(stderr, "Could not allocate picture\n");
285 exit(1);
286 }
287
288 /* If the output format is not YUV420P, then a temporary YUV420P
289 * picture is needed too. It is then converted to the required
290 * output format. */
291 tmp_picture = NULL;
292 if (c->pix_fmt != PIX_FMT_YUV420P) {
293 tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);
294 if (!tmp_picture) {
295 fprintf(stderr, "Could not allocate temporary picture\n");
296 exit(1);
297 }
298 }
299 }
300
301 /* Prepare a dummy image. */
302 static void fill_yuv_image(AVFrame *pict, int frame_index,
303 int width, int height)
304 {
305 int x, y, i;
306
307 i = frame_index;
308
309 /* Y */
310 for (y = 0; y < height; y++)
311 for (x = 0; x < width; x++)
312 pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
313
314 /* Cb and Cr */
315 for (y = 0; y < height / 2; y++) {
316 for (x = 0; x < width / 2; x++) {
317 pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
318 pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
319 }
320 }
321 }
322
323 static void write_video_frame(AVFormatContext *oc, AVStream *st)
324 {
325 int out_size, ret;
326 AVCodecContext *c;
327 static struct SwsContext *img_convert_ctx;
328
329 c = st->codec;
330
331 if (frame_count >= STREAM_NB_FRAMES) {
332 /* No more frames to compress. The codec has a latency of a few
333 * frames if using B-frames, so we get the last frames by
334 * passing the same picture again. */
335 } else {
336 if (c->pix_fmt != PIX_FMT_YUV420P) {
337 /* as we only generate a YUV420P picture, we must convert it
338 * to the codec pixel format if needed */
339 if (img_convert_ctx == NULL) {
340 img_convert_ctx = sws_getContext(c->width, c->height,
341 PIX_FMT_YUV420P,
342 c->width, c->height,
343 c->pix_fmt,
344 sws_flags, NULL, NULL, NULL);
345 if (img_convert_ctx == NULL) {
346 fprintf(stderr,
347 "Cannot initialize the conversion context\n");
348 exit(1);
349 }
350 }
351 fill_yuv_image(tmp_picture, frame_count, c->width, c->height);
352 sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize,
353 0, c->height, picture->data, picture->linesize);
354 } else {
355 fill_yuv_image(picture, frame_count, c->width, c->height);
356 }
357 }
358
359 if (oc->oformat->flags & AVFMT_RAWPICTURE) {
360 /* Raw video case - the API will change slightly in the near
361 * future for that. */
362 AVPacket pkt;
363 av_init_packet(&pkt);
364
365 pkt.flags |= AV_PKT_FLAG_KEY;
366 pkt.stream_index = st->index;
367 pkt.data = (uint8_t *)picture;
368 pkt.size = sizeof(AVPicture);
369
370 ret = av_interleaved_write_frame(oc, &pkt);
371 } else {
372 /* encode the image */
373 out_size = avcodec_encode_video(c, video_outbuf,
374 video_outbuf_size, picture);
375 /* If size is zero, it means the image was buffered. */
376 if (out_size > 0) {
377 AVPacket pkt;
378 av_init_packet(&pkt);
379
380 if (c->coded_frame->pts != AV_NOPTS_VALUE)
381 pkt.pts = av_rescale_q(c->coded_frame->pts,
382 c->time_base, st->time_base);
383 if (c->coded_frame->key_frame)
384 pkt.flags |= AV_PKT_FLAG_KEY;
385 pkt.stream_index = st->index;
386 pkt.data = video_outbuf;
387 pkt.size = out_size;
388
389 /* Write the compressed frame to the media file. */
390 ret = av_interleaved_write_frame(oc, &pkt);
391 } else {
392 ret = 0;
393 }
394 }
395 if (ret != 0) {
396 fprintf(stderr, "Error while writing video frame\n");
397 exit(1);
398 }
399 frame_count++;
400 }
401
402 static void close_video(AVFormatContext *oc, AVStream *st)
403 {
404 avcodec_close(st->codec);
405 av_free(picture->data[0]);
406 av_free(picture);
407 if (tmp_picture) {
408 av_free(tmp_picture->data[0]);
409 av_free(tmp_picture);
410 }
411 av_free(video_outbuf);
412 }
413
414 /**************************************************************/
415 /* media file output */
416
417 int main(int argc, char **argv)
418 {
419 const char *filename;
420 AVOutputFormat *fmt;
421 AVFormatContext *oc;
422 AVStream *audio_st, *video_st;
423 double audio_pts, video_pts;
424 int i;
425
426 /* Initialize libavcodec, and register all codecs and formats. */
427 av_register_all();
428
429 if (argc != 2) {
430 printf("usage: %s output_file\n"
431 "API example program to output a media file with libavformat.\n"
432 "The output format is automatically guessed according to the file extension.\n"
433 "Raw images can also be output by using '%%d' in the filename\n"
434 "\n", argv[0]);
435 return 1;
436 }
437
438 filename = argv[1];
439
440 /* Autodetect the output format from the name. default is MPEG. */
441 fmt = av_guess_format(NULL, filename, NULL);
442 if (!fmt) {
443 printf("Could not deduce output format from file extension: using MPEG.\n");
444 fmt = av_guess_format("mpeg", NULL, NULL);
445 }
446 if (!fmt) {
447 fprintf(stderr, "Could not find suitable output format\n");
448 return 1;
449 }
450
451 /* Allocate the output media context. */
452 oc = avformat_alloc_context();
453 if (!oc) {
454 fprintf(stderr, "Memory error\n");
455 return 1;
456 }
457 oc->oformat = fmt;
458 snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
459
460 /* Add the audio and video streams using the default format codecs
461 * and initialize the codecs. */
462 video_st = NULL;
463 audio_st = NULL;
464 if (fmt->video_codec != AV_CODEC_ID_NONE) {
465 video_st = add_video_stream(oc, fmt->video_codec);
466 }
467 if (fmt->audio_codec != AV_CODEC_ID_NONE) {
468 audio_st = add_audio_stream(oc, fmt->audio_codec);
469 }
470
471 /* Now that all the parameters are set, we can open the audio and
472 * video codecs and allocate the necessary encode buffers. */
473 if (video_st)
474 open_video(oc, video_st);
475 if (audio_st)
476 open_audio(oc, audio_st);
477
478 av_dump_format(oc, 0, filename, 1);
479
480 /* open the output file, if needed */
481 if (!(fmt->flags & AVFMT_NOFILE)) {
482 if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
483 fprintf(stderr, "Could not open '%s'\n", filename);
484 return 1;
485 }
486 }
487
488 /* Write the stream header, if any. */
489 avformat_write_header(oc, NULL);
490
491 for (;;) {
492 /* Compute current audio and video time. */
493 if (audio_st)
494 audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
495 else
496 audio_pts = 0.0;
497
498 if (video_st)
499 video_pts = (double)video_st->pts.val * video_st->time_base.num /
500 video_st->time_base.den;
501 else
502 video_pts = 0.0;
503
504 if ((!audio_st || audio_pts >= STREAM_DURATION) &&
505 (!video_st || video_pts >= STREAM_DURATION))
506 break;
507
508 /* write interleaved audio and video frames */
509 if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
510 write_audio_frame(oc, audio_st);
511 } else {
512 write_video_frame(oc, video_st);
513 }
514 }
515
516 /* Write the trailer, if any. The trailer must be written before you
517 * close the CodecContexts open when you wrote the header; otherwise
518 * av_write_trailer() may try to use memory that was freed on
519 * av_codec_close(). */
520 av_write_trailer(oc);
521
522 /* Close each codec. */
523 if (video_st)
524 close_video(oc, video_st);
525 if (audio_st)
526 close_audio(oc, audio_st);
527
528 /* Free the streams. */
529 for (i = 0; i < oc->nb_streams; i++) {
530 av_freep(&oc->streams[i]->codec);
531 av_freep(&oc->streams[i]);
532 }
533
534 if (!(fmt->flags & AVFMT_NOFILE))
535 /* Close the output file. */
536 avio_close(oc->pb);
537
538 /* free the stream */
539 av_free(oc);
540
541 return 0;
542 }