27950a162b6c732dd6ad72b803c2c11d4335dbcf
[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 }
169
170 static void close_audio(AVFormatContext *oc, AVStream *st)
171 {
172 avcodec_close(st->codec);
173
174 av_free(samples);
175 }
176
177 /**************************************************************/
178 /* video output */
179
180 static AVFrame *picture, *tmp_picture;
181 static uint8_t *video_outbuf;
182 static int frame_count, video_outbuf_size;
183
184 /* Add a video output stream. */
185 static AVStream *add_video_stream(AVFormatContext *oc, enum AVCodecID codec_id)
186 {
187 AVCodecContext *c;
188 AVStream *st;
189 AVCodec *codec;
190
191 /* find the video encoder */
192 codec = avcodec_find_encoder(codec_id);
193 if (!codec) {
194 fprintf(stderr, "codec not found\n");
195 exit(1);
196 }
197
198 st = avformat_new_stream(oc, codec);
199 if (!st) {
200 fprintf(stderr, "Could not alloc stream\n");
201 exit(1);
202 }
203
204 c = st->codec;
205
206 /* Put sample parameters. */
207 c->bit_rate = 400000;
208 /* Resolution must be a multiple of two. */
209 c->width = 352;
210 c->height = 288;
211 /* timebase: This is the fundamental unit of time (in seconds) in terms
212 * of which frame timestamps are represented. For fixed-fps content,
213 * timebase should be 1/framerate and timestamp increments should be
214 * identical to 1. */
215 c->time_base.den = STREAM_FRAME_RATE;
216 c->time_base.num = 1;
217 c->gop_size = 12; /* emit one intra frame every twelve frames at most */
218 c->pix_fmt = STREAM_PIX_FMT;
219 if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
220 /* just for testing, we also add B frames */
221 c->max_b_frames = 2;
222 }
223 if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
224 /* Needed to avoid using macroblocks in which some coeffs overflow.
225 * This does not happen with normal video, it just happens here as
226 * the motion of the chroma plane does not match the luma plane. */
227 c->mb_decision = 2;
228 }
229 /* Some formats want stream headers to be separate. */
230 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
231 c->flags |= CODEC_FLAG_GLOBAL_HEADER;
232
233 return st;
234 }
235
236 static AVFrame *alloc_picture(enum PixelFormat pix_fmt, int width, int height)
237 {
238 AVFrame *picture;
239 uint8_t *picture_buf;
240 int size;
241
242 picture = avcodec_alloc_frame();
243 if (!picture)
244 return NULL;
245 size = avpicture_get_size(pix_fmt, width, height);
246 picture_buf = av_malloc(size);
247 if (!picture_buf) {
248 av_free(picture);
249 return NULL;
250 }
251 avpicture_fill((AVPicture *)picture, picture_buf,
252 pix_fmt, width, height);
253 return picture;
254 }
255
256 static void open_video(AVFormatContext *oc, AVStream *st)
257 {
258 AVCodecContext *c;
259
260 c = st->codec;
261
262 /* open the codec */
263 if (avcodec_open2(c, NULL, NULL) < 0) {
264 fprintf(stderr, "could not open codec\n");
265 exit(1);
266 }
267
268 video_outbuf = NULL;
269 if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
270 /* Allocate output buffer. */
271 /* XXX: API change will be done. */
272 /* Buffers passed into lav* can be allocated any way you prefer,
273 * as long as they're aligned enough for the architecture, and
274 * they're freed appropriately (such as using av_free for buffers
275 * allocated with av_malloc). */
276 video_outbuf_size = 200000;
277 video_outbuf = av_malloc(video_outbuf_size);
278 }
279
280 /* Allocate the encoded raw picture. */
281 picture = alloc_picture(c->pix_fmt, c->width, c->height);
282 if (!picture) {
283 fprintf(stderr, "Could not allocate picture\n");
284 exit(1);
285 }
286
287 /* If the output format is not YUV420P, then a temporary YUV420P
288 * picture is needed too. It is then converted to the required
289 * output format. */
290 tmp_picture = NULL;
291 if (c->pix_fmt != PIX_FMT_YUV420P) {
292 tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);
293 if (!tmp_picture) {
294 fprintf(stderr, "Could not allocate temporary picture\n");
295 exit(1);
296 }
297 }
298 }
299
300 /* Prepare a dummy image. */
301 static void fill_yuv_image(AVFrame *pict, int frame_index,
302 int width, int height)
303 {
304 int x, y, i;
305
306 i = frame_index;
307
308 /* Y */
309 for (y = 0; y < height; y++)
310 for (x = 0; x < width; x++)
311 pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
312
313 /* Cb and Cr */
314 for (y = 0; y < height / 2; y++) {
315 for (x = 0; x < width / 2; x++) {
316 pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
317 pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
318 }
319 }
320 }
321
322 static void write_video_frame(AVFormatContext *oc, AVStream *st)
323 {
324 int out_size, ret;
325 AVCodecContext *c;
326 static struct SwsContext *img_convert_ctx;
327
328 c = st->codec;
329
330 if (frame_count >= STREAM_NB_FRAMES) {
331 /* No more frames to compress. The codec has a latency of a few
332 * frames if using B-frames, so we get the last frames by
333 * passing the same picture again. */
334 } else {
335 if (c->pix_fmt != PIX_FMT_YUV420P) {
336 /* as we only generate a YUV420P picture, we must convert it
337 * to the codec pixel format if needed */
338 if (img_convert_ctx == NULL) {
339 img_convert_ctx = sws_getContext(c->width, c->height,
340 PIX_FMT_YUV420P,
341 c->width, c->height,
342 c->pix_fmt,
343 sws_flags, NULL, NULL, NULL);
344 if (img_convert_ctx == NULL) {
345 fprintf(stderr,
346 "Cannot initialize the conversion context\n");
347 exit(1);
348 }
349 }
350 fill_yuv_image(tmp_picture, frame_count, c->width, c->height);
351 sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize,
352 0, c->height, picture->data, picture->linesize);
353 } else {
354 fill_yuv_image(picture, frame_count, c->width, c->height);
355 }
356 }
357
358 if (oc->oformat->flags & AVFMT_RAWPICTURE) {
359 /* Raw video case - the API will change slightly in the near
360 * future for that. */
361 AVPacket pkt;
362 av_init_packet(&pkt);
363
364 pkt.flags |= AV_PKT_FLAG_KEY;
365 pkt.stream_index = st->index;
366 pkt.data = (uint8_t *)picture;
367 pkt.size = sizeof(AVPicture);
368
369 ret = av_interleaved_write_frame(oc, &pkt);
370 } else {
371 /* encode the image */
372 out_size = avcodec_encode_video(c, video_outbuf,
373 video_outbuf_size, picture);
374 /* If size is zero, it means the image was buffered. */
375 if (out_size > 0) {
376 AVPacket pkt;
377 av_init_packet(&pkt);
378
379 if (c->coded_frame->pts != AV_NOPTS_VALUE)
380 pkt.pts = av_rescale_q(c->coded_frame->pts,
381 c->time_base, st->time_base);
382 if (c->coded_frame->key_frame)
383 pkt.flags |= AV_PKT_FLAG_KEY;
384 pkt.stream_index = st->index;
385 pkt.data = video_outbuf;
386 pkt.size = out_size;
387
388 /* Write the compressed frame to the media file. */
389 ret = av_interleaved_write_frame(oc, &pkt);
390 } else {
391 ret = 0;
392 }
393 }
394 if (ret != 0) {
395 fprintf(stderr, "Error while writing video frame\n");
396 exit(1);
397 }
398 frame_count++;
399 }
400
401 static void close_video(AVFormatContext *oc, AVStream *st)
402 {
403 avcodec_close(st->codec);
404 av_free(picture->data[0]);
405 av_free(picture);
406 if (tmp_picture) {
407 av_free(tmp_picture->data[0]);
408 av_free(tmp_picture);
409 }
410 av_free(video_outbuf);
411 }
412
413 /**************************************************************/
414 /* media file output */
415
416 int main(int argc, char **argv)
417 {
418 const char *filename;
419 AVOutputFormat *fmt;
420 AVFormatContext *oc;
421 AVStream *audio_st, *video_st;
422 double audio_pts, video_pts;
423 int i;
424
425 /* Initialize libavcodec, and register all codecs and formats. */
426 av_register_all();
427
428 if (argc != 2) {
429 printf("usage: %s output_file\n"
430 "API example program to output a media file with libavformat.\n"
431 "The output format is automatically guessed according to the file extension.\n"
432 "Raw images can also be output by using '%%d' in the filename\n"
433 "\n", argv[0]);
434 return 1;
435 }
436
437 filename = argv[1];
438
439 /* Autodetect the output format from the name. default is MPEG. */
440 fmt = av_guess_format(NULL, filename, NULL);
441 if (!fmt) {
442 printf("Could not deduce output format from file extension: using MPEG.\n");
443 fmt = av_guess_format("mpeg", NULL, NULL);
444 }
445 if (!fmt) {
446 fprintf(stderr, "Could not find suitable output format\n");
447 return 1;
448 }
449
450 /* Allocate the output media context. */
451 oc = avformat_alloc_context();
452 if (!oc) {
453 fprintf(stderr, "Memory error\n");
454 return 1;
455 }
456 oc->oformat = fmt;
457 snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
458
459 /* Add the audio and video streams using the default format codecs
460 * and initialize the codecs. */
461 video_st = NULL;
462 audio_st = NULL;
463 if (fmt->video_codec != AV_CODEC_ID_NONE) {
464 video_st = add_video_stream(oc, fmt->video_codec);
465 }
466 if (fmt->audio_codec != AV_CODEC_ID_NONE) {
467 audio_st = add_audio_stream(oc, fmt->audio_codec);
468 }
469
470 /* Now that all the parameters are set, we can open the audio and
471 * video codecs and allocate the necessary encode buffers. */
472 if (video_st)
473 open_video(oc, video_st);
474 if (audio_st)
475 open_audio(oc, audio_st);
476
477 av_dump_format(oc, 0, filename, 1);
478
479 /* open the output file, if needed */
480 if (!(fmt->flags & AVFMT_NOFILE)) {
481 if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
482 fprintf(stderr, "Could not open '%s'\n", filename);
483 return 1;
484 }
485 }
486
487 /* Write the stream header, if any. */
488 avformat_write_header(oc, NULL);
489
490 for (;;) {
491 /* Compute current audio and video time. */
492 if (audio_st)
493 audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
494 else
495 audio_pts = 0.0;
496
497 if (video_st)
498 video_pts = (double)video_st->pts.val * video_st->time_base.num /
499 video_st->time_base.den;
500 else
501 video_pts = 0.0;
502
503 if ((!audio_st || audio_pts >= STREAM_DURATION) &&
504 (!video_st || video_pts >= STREAM_DURATION))
505 break;
506
507 /* write interleaved audio and video frames */
508 if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
509 write_audio_frame(oc, audio_st);
510 } else {
511 write_video_frame(oc, video_st);
512 }
513 }
514
515 /* Write the trailer, if any. The trailer must be written before you
516 * close the CodecContexts open when you wrote the header; otherwise
517 * av_write_trailer() may try to use memory that was freed on
518 * av_codec_close(). */
519 av_write_trailer(oc);
520
521 /* Close each codec. */
522 if (video_st)
523 close_video(oc, video_st);
524 if (audio_st)
525 close_audio(oc, audio_st);
526
527 /* Free the streams. */
528 for (i = 0; i < oc->nb_streams; i++) {
529 av_freep(&oc->streams[i]->codec);
530 av_freep(&oc->streams[i]);
531 }
532
533 if (!(fmt->flags & AVFMT_NOFILE))
534 /* Close the output file. */
535 avio_close(oc->pb);
536
537 /* free the stream */
538 av_free(oc);
539
540 return 0;
541 }