use MAKE variable
[libav.git] / ffmpeg.c
CommitLineData
85f07f22
FB
1/*
2 * FFmpeg main
3 * Copyright (c) 2000,2001 Gerard Lantau
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19#include <stdlib.h>
20#include <stdio.h>
21#include <unistd.h>
22#include <fcntl.h>
23#include <sys/ioctl.h>
24#include <errno.h>
25#include <sys/time.h>
26#include <string.h>
27#include <sys/poll.h>
28#include <termios.h>
5727b222
FB
29#include <sys/time.h>
30#include <sys/resource.h>
85f07f22
FB
31#include <ctype.h>
32
33#include "avformat.h"
34
35typedef struct {
36 const char *name;
37 int flags;
38#define HAS_ARG 0x0001
39#define OPT_BOOL 0x0002
40#define OPT_EXPERT 0x0004
41#define OPT_STRING 0x0008
42 union {
43 void (*func_arg)();
44 int *int_arg;
45 char **str_arg;
46 } u;
47 const char *help;
48 const char *argname;
49} OptionDef;
50
51/* select an input stream for an output stream */
52typedef struct AVStreamMap {
53 int file_index;
54 int stream_index;
55} AVStreamMap;
56
57extern const OptionDef options[];
58
59void show_help(void);
60
61#define MAX_FILES 20
62
63static AVFormatContext *input_files[MAX_FILES];
64static int nb_input_files = 0;
65
66static AVFormatContext *output_files[MAX_FILES];
67static int nb_output_files = 0;
68
69static AVStreamMap stream_maps[MAX_FILES];
70static int nb_stream_maps;
71
72static AVFormat *file_format;
73static int frame_width = 160;
74static int frame_height = 128;
75static int frame_rate = 25 * FRAME_RATE_BASE;
76static int video_bit_rate = 200000;
77static int video_qscale = 0;
78static int video_disable = 0;
79static int video_codec_id = CODEC_ID_NONE;
80static int same_quality = 0;
81
82static int gop_size = 12;
83static int intra_only = 0;
84static int audio_sample_rate = 44100;
85static int audio_bit_rate = 64000;
86static int audio_disable = 0;
87static int audio_channels = 1;
88static int audio_codec_id = CODEC_ID_NONE;
89
90static INT64 recording_time = 0;
91static int file_overwrite = 0;
92static char *str_title = NULL;
93static char *str_author = NULL;
94static char *str_copyright = NULL;
95static char *str_comment = NULL;
5727b222 96static int do_benchmark = 0;
85f07f22
FB
97
98typedef struct AVOutputStream {
99 int file_index; /* file index */
100 int index; /* stream index in the output file */
101 int source_index; /* AVInputStream index */
102 AVStream *st; /* stream in the output file */
103 int encoding_needed; /* true if encoding needed for this stream */
104
105 int fifo_packet_rptr; /* read index in the corresponding
106 avinputstream packet fifo */
107 /* video only */
108 AVPicture pict_tmp; /* temporary image for resizing */
109 int video_resample;
110 ImgReSampleContext *img_resample_ctx; /* for image resampling */
111
112 /* audio only */
113 int audio_resample;
114 ReSampleContext *resample; /* for audio resampling */
115 FifoBuffer fifo; /* for compression: one audio fifo per codec */
116} AVOutputStream;
117
118typedef struct AVInputStream {
119 int file_index;
120 int index;
121 AVStream *st;
122 int discard; /* true if stream data should be discarded */
123 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
124 INT64 pts; /* current pts */
125 int frame_number; /* current frame */
126 INT64 sample_index; /* current sample */
127} AVInputStream;
128
129typedef struct AVInputFile {
130 int eof_reached; /* true if eof reached */
131 int ist_index; /* index of first stream in ist_table */
132 int buffer_size; /* current total buffer size */
133 int buffer_size_max; /* buffer size at which we consider we can stop
134 buffering */
135} AVInputFile;
136
137/* init terminal so that we can grab keys */
138static struct termios oldtty;
139
140static void term_exit(void)
141{
142 tcsetattr (0, TCSANOW, &oldtty);
143}
144
145static void term_init(void)
146{
147 struct termios tty;
148
149 tcgetattr (0, &tty);
150 oldtty = tty;
151
152 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
153 |INLCR|IGNCR|ICRNL|IXON);
154 tty.c_oflag |= OPOST;
155 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
156 tty.c_cflag &= ~(CSIZE|PARENB);
157 tty.c_cflag |= CS8;
158 tty.c_cc[VMIN] = 1;
159 tty.c_cc[VTIME] = 0;
160
161 tcsetattr (0, TCSANOW, &tty);
162
163 atexit(term_exit);
164}
165
166/* read a key without blocking */
167static int read_key(void)
168{
169 struct timeval tv;
170 int n;
171 unsigned char ch;
172 fd_set rfds;
173
174 FD_ZERO(&rfds);
175 FD_SET(0, &rfds);
176 tv.tv_sec = 0;
177 tv.tv_usec = 0;
178 n = select(1, &rfds, NULL, NULL, &tv);
179 if (n > 0) {
180 if (read(0, &ch, 1) == 1)
181 return ch;
182 }
183 return -1;
184}
185
186#define AUDIO_FIFO_SIZE 8192
187
188/* main loop for grabbing */
189int av_grab(AVFormatContext *s)
190{
191 UINT8 audio_buf[AUDIO_FIFO_SIZE/2];
192 UINT8 audio_buf1[AUDIO_FIFO_SIZE/2];
193 UINT8 audio_out[AUDIO_FIFO_SIZE/2];
194 UINT8 video_buffer[128*1024];
195 char buf[256];
196 short *samples;
197 URLContext *audio_handle = NULL, *video_handle = NULL;
198 int ret;
199 AVCodecContext *enc, *first_video_enc = NULL;
200 int frame_size, frame_bytes;
201 int use_audio, use_video;
202 int frame_rate, sample_rate, channels;
203 int width, height, frame_number, i, pix_fmt = 0;
204 AVOutputStream *ost_table[s->nb_streams], *ost;
205 UINT8 *picture_in_buf = NULL, *picture_420p = NULL;
206 int audio_fifo_size = 0, picture_size = 0;
207 INT64 time_start;
208
209 /* init output stream info */
210 for(i=0;i<s->nb_streams;i++)
211 ost_table[i] = NULL;
212
213 /* output stream init */
214 for(i=0;i<s->nb_streams;i++) {
215 ost = av_mallocz(sizeof(AVOutputStream));
216 if (!ost)
217 goto fail;
218 ost->index = i;
219 ost->st = s->streams[i];
220 ost_table[i] = ost;
221 }
222
223 use_audio = 0;
224 use_video = 0;
225 frame_rate = 0;
226 sample_rate = 0;
227 frame_size = 0;
228 channels = 1;
229 width = 0;
230 height = 0;
231 frame_number = 0;
232
233 for(i=0;i<s->nb_streams;i++) {
234 AVCodec *codec;
235
236 ost = ost_table[i];
237 enc = &ost->st->codec;
238 codec = avcodec_find_encoder(enc->codec_id);
239 if (!codec) {
240 fprintf(stderr, "Unknown codec\n");
241 return -1;
242 }
243 if (avcodec_open(enc, codec) < 0) {
244 fprintf(stderr, "Incorrect encode parameters\n");
245 return -1;
246 }
247 switch(enc->codec_type) {
248 case CODEC_TYPE_AUDIO:
249 use_audio = 1;
250 if (enc->sample_rate > sample_rate)
251 sample_rate = enc->sample_rate;
252 if (enc->frame_size > frame_size)
253 frame_size = enc->frame_size;
254 if (enc->channels > channels)
255 channels = enc->channels;
256 break;
257 case CODEC_TYPE_VIDEO:
258 if (!first_video_enc)
259 first_video_enc = enc;
260 use_video = 1;
261 if (enc->frame_rate > frame_rate)
262 frame_rate = enc->frame_rate;
263 if (enc->width > width)
264 width = enc->width;
265 if (enc->height > height)
266 height = enc->height;
267 break;
268 }
269 }
270
271 /* audio */
272 samples = NULL;
273 if (use_audio) {
274 snprintf(buf, sizeof(buf), "audio:%d,%d", sample_rate, channels);
275 ret = url_open(&audio_handle, buf, URL_RDONLY);
276 if (ret < 0) {
277 fprintf(stderr, "Could not open audio device: disabling audio capture\n");
278 use_audio = 0;
279 } else {
280 URLFormat f;
281 /* read back exact grab parameters */
282 if (url_getformat(audio_handle, &f) < 0) {
283 fprintf(stderr, "could not read back video grab parameters\n");
284 goto fail;
285 }
286 sample_rate = f.sample_rate;
287 channels = f.channels;
288 audio_fifo_size = ((AUDIO_FIFO_SIZE / 2) / audio_handle->packet_size) *
289 audio_handle->packet_size;
290 fprintf(stderr, "Audio sampling: %d Hz, %s\n",
291 sample_rate, channels == 2 ? "stereo" : "mono");
292 }
293 }
294
295 /* video */
296 if (use_video) {
297 snprintf(buf, sizeof(buf), "video:%d,%d,%f",
298 width, height, (float)frame_rate / FRAME_RATE_BASE);
299
300 ret = url_open(&video_handle, buf, URL_RDONLY);
301 if (ret < 0) {
302 fprintf(stderr,"Could not init video 4 linux capture: disabling video capture\n");
303 use_video = 0;
304 } else {
305 URLFormat f;
306 const char *pix_fmt_str;
307 /* read back exact grab parameters */
308 if (url_getformat(video_handle, &f) < 0) {
309 fprintf(stderr, "could not read back video grab parameters\n");
310 goto fail;
311 }
312 width = f.width;
313 height = f.height;
314 pix_fmt = f.pix_fmt;
315 switch(pix_fmt) {
316 case PIX_FMT_YUV420P:
317 pix_fmt_str = "420P";
318 break;
319 case PIX_FMT_YUV422:
320 pix_fmt_str = "422";
321 break;
322 case PIX_FMT_RGB24:
323 pix_fmt_str = "RGB24";
324 break;
325 case PIX_FMT_BGR24:
326 pix_fmt_str = "BGR24";
327 break;
328 default:
329 pix_fmt_str = "???";
330 break;
331 }
332 picture_size = video_handle->packet_size;
333 picture_in_buf = malloc(picture_size);
334 if (!picture_in_buf)
335 goto fail;
336 /* allocate a temporary picture if not grabbing in 420P format */
337 if (pix_fmt != PIX_FMT_YUV420P) {
338 picture_420p = malloc((width * height * 3) / 2);
339 }
340 fprintf(stderr, "Video sampling: %dx%d, %s format, %0.2f fps\n",
341 width, height, pix_fmt_str, (float)frame_rate / FRAME_RATE_BASE);
342 }
343 }
344
345 if (!use_video && !use_audio) {
346 fprintf(stderr,"Could not open grab devices : exiting\n");
347 exit(1);
348 }
349
350 /* init built in conversion functions */
351 for(i=0;i<s->nb_streams;i++) {
352 ost = ost_table[i];
353 enc = &ost->st->codec;
354 switch(enc->codec_type) {
355 case CODEC_TYPE_AUDIO:
356 ost->audio_resample = 0;
357 if ((enc->channels != channels ||
358 enc->sample_rate != sample_rate)) {
359 ost->audio_resample = 1;
360 ost->resample = audio_resample_init(enc->channels, channels,
361 enc->sample_rate, sample_rate);
362 }
363 if (fifo_init(&ost->fifo, (2 * audio_fifo_size * enc->sample_rate) /
364 sample_rate))
365 goto fail;
366 break;
367 case CODEC_TYPE_VIDEO:
368 ost->video_resample = 0;
369 if (enc->width != width ||
370 enc->height != height) {
371 UINT8 *buf;
372 ost->video_resample = 1;
373 buf = malloc((enc->width * enc->height * 3) / 2);
374 if (!buf)
375 goto fail;
376 ost->pict_tmp.data[0] = buf;
377 ost->pict_tmp.data[1] = buf + enc->width * height;
378 ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (enc->width * height) / 4;
379 ost->pict_tmp.linesize[0] = enc->width;
380 ost->pict_tmp.linesize[1] = enc->width / 2;
381 ost->pict_tmp.linesize[2] = enc->width / 2;
382 ost->img_resample_ctx = img_resample_init(
383 ost->st->codec.width, ost->st->codec.height,
384 width, height);
385 }
386 }
387 }
388
389 fprintf(stderr, "Press [q] to stop encoding\n");
390
391 s->format->write_header(s);
392 time_start = gettime();
393 term_init();
394
395 for(;;) {
396 /* if 'q' pressed, exits */
397 if (read_key() == 'q')
398 break;
399
400 /* read & compress audio frames */
401 if (use_audio) {
402 int ret, nb_samples, nb_samples_out;
403 UINT8 *buftmp;
404
405 for(;;) {
406 ret = url_read(audio_handle, audio_buf, audio_fifo_size);
407 if (ret <= 0)
408 break;
409 /* fill each codec fifo by doing the right sample
410 rate conversion. This is not optimal because we
411 do too much work, but it is easy to do */
412 nb_samples = ret / (channels * 2);
413 for(i=0;i<s->nb_streams;i++) {
414 ost = ost_table[i];
415 enc = &ost->st->codec;
416 if (enc->codec_type == CODEC_TYPE_AUDIO) {
417 /* rate & stereo convertion */
418 if (!ost->audio_resample) {
419 buftmp = audio_buf;
420 nb_samples_out = nb_samples;
421 } else {
422 buftmp = audio_buf1;
423 nb_samples_out = audio_resample(ost->resample,
424 (short *)buftmp, (short *)audio_buf,
425 nb_samples);
426 }
427 fifo_write(&ost->fifo, buftmp, nb_samples_out * enc->channels * 2,
428 &ost->fifo.wptr);
429 }
430 }
431
432 /* compress as many frame as possible with each audio codec */
433 for(i=0;i<s->nb_streams;i++) {
434 ost = ost_table[i];
435 enc = &ost->st->codec;
436 if (enc->codec_type == CODEC_TYPE_AUDIO) {
437 frame_bytes = enc->frame_size * 2 * enc->channels;
438
439 while (fifo_read(&ost->fifo, audio_buf,
440 frame_bytes, &ost->fifo.rptr) == 0) {
441 ret = avcodec_encode_audio(enc,
442 audio_out, sizeof(audio_out),
443 (short *)audio_buf);
444 s->format->write_packet(s, ost->index, audio_out, ret);
445 }
446 }
447 }
448 }
449 }
450
451 if (use_video) {
452 AVPicture *picture1;
453 AVPicture picture;
454 UINT8 *pict_buffer;
455
456 ret = url_read(video_handle, picture_in_buf, picture_size);
457 if (ret < 0)
458 break;
459 if (pix_fmt != PIX_FMT_YUV420P) {
460 pict_buffer = picture_420p;
461 img_convert_to_yuv420(pict_buffer, picture_in_buf, pix_fmt, width, height);
462 } else {
463 pict_buffer = picture_in_buf;
464 }
465 /* build a picture storage */
466 picture.data[0] = pict_buffer;
467 picture.data[1] = picture.data[0] + width * height;
468 picture.data[2] = picture.data[1] + (width * height) / 4;
469 picture.linesize[0] = width;
470 picture.linesize[1] = width / 2;
471 picture.linesize[2] = width / 2;
472
473 for(i=0;i<s->nb_streams;i++) {
474 ost = ost_table[i];
475 enc = &ost->st->codec;
476 if (enc->codec_type == CODEC_TYPE_VIDEO) {
477 int n1, n2, nb;
478
479 /* feed each codec with its requested frame rate */
480 n1 = ((INT64)frame_number * enc->frame_rate) / frame_rate;
481 n2 = (((INT64)frame_number + 1) * enc->frame_rate) / frame_rate;
482 nb = n2 - n1;
483 if (nb > 0) {
484 /* resize the picture if needed */
485 if (ost->video_resample) {
486 picture1 = &ost->pict_tmp;
487 img_resample(ost->img_resample_ctx,
488 picture1, &picture);
489 } else {
490 picture1 = &picture;
491 }
492 ret = avcodec_encode_video(enc, video_buffer,
493 sizeof(video_buffer),
494 picture1);
495 s->format->write_packet(s, ost->index, video_buffer, ret);
496 }
497 }
498 }
499 frame_number++;
500 }
501
502 /* write report */
503 {
504 char buf[1024];
505 INT64 total_size;
506 float ti, bitrate;
507 static float last_ti;
508 INT64 ti1;
509
510 total_size = url_ftell(&s->pb);
511 ti1 = gettime() - time_start;
512 /* check elapsed time */
513 if (recording_time && ti1 >= recording_time)
514 break;
515
516 ti = ti1 / 1000000.0;
517 if (ti < 0.1)
518 ti = 0.1;
519 /* dispaly twice per second */
520 if ((ti - last_ti) >= 0.5) {
521 last_ti = ti;
522 bitrate = (int)((total_size * 8) / ti / 1000.0);
523
524 buf[0] = '\0';
525 if (use_video) {
526 sprintf(buf + strlen(buf), "frame=%5d fps=%4.1f q=%2d ",
527 frame_number, (float)frame_number / ti, first_video_enc->quality);
528 }
529
530 sprintf(buf + strlen(buf), "size=%8LdkB time=%0.1f bitrate=%6.1fkbits/s",
531 total_size / 1024, ti, bitrate);
532 fprintf(stderr, "%s \r", buf);
533 fflush(stderr);
534 }
535 }
536 }
537 term_exit();
538
539 for(i=0;i<s->nb_streams;i++) {
540 ost = ost_table[i];
541 enc = &ost->st->codec;
542 avcodec_close(enc);
543 }
544 s->format->write_trailer(s);
545
546 if (audio_handle)
547 url_close(audio_handle);
548
549 if (video_handle)
550 url_close(video_handle);
551
552 /* write report */
553 {
554 float ti, bitrate;
555 INT64 total_size;
556
557 total_size = url_ftell(&s->pb);
558
559 ti = (gettime() - time_start) / 1000000.0;
560 if (ti < 0.1)
561 ti = 0.1;
562 bitrate = (int)((total_size * 8) / ti / 1000.0);
563
564 fprintf(stderr, "\033[K\nTotal time = %0.1f s, %Ld KBytes, %0.1f kbits/s\n",
565 ti, total_size / 1024, bitrate);
566 if (use_video) {
567 fprintf(stderr, "Total frames = %d\n", frame_number);
568 }
569 }
570
571 ret = 0;
572 fail1:
573 if (picture_in_buf)
574 free(picture_in_buf);
575 if (picture_420p)
576 free(picture_420p);
577 for(i=0;i<s->nb_streams;i++) {
578 ost = ost_table[i];
579 if (ost) {
580 if (ost->fifo.buffer)
581 fifo_free(&ost->fifo);
582 if (ost->pict_tmp.data[0])
583 free(ost->pict_tmp.data[0]);
584 if (ost->video_resample)
585 img_resample_close(ost->img_resample_ctx);
586 if (ost->audio_resample)
587 audio_resample_close(ost->resample);
588 free(ost);
589 }
590 }
591 return ret;
592 fail:
593 ret = -ENOMEM;
594 goto fail1;
595}
596
597int read_ffserver_streams(AVFormatContext *s, const char *filename)
598{
599 int i;
600 AVFormatContext *ic;
601
602 ic = av_open_input_file(filename, FFM_PACKET_SIZE);
603 if (!ic)
604 return -EIO;
605 /* copy stream format */
606 s->nb_streams = ic->nb_streams;
607 for(i=0;i<ic->nb_streams;i++) {
608 AVStream *st;
609 st = av_mallocz(sizeof(AVFormatContext));
610 memcpy(st, ic->streams[i], sizeof(AVStream));
611 s->streams[i] = st;
612 }
613
614 av_close_input_file(ic);
615 return 0;
616}
617
618#define MAX_AUDIO_PACKET_SIZE 16384
619
620static void do_audio_out(AVFormatContext *s,
621 AVOutputStream *ost,
622 AVInputStream *ist,
623 unsigned char *buf, int size)
624{
625 UINT8 *buftmp;
626 UINT8 audio_buf[2*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
627 UINT8 audio_out[MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
628 int size_out, frame_bytes, ret;
629 AVCodecContext *enc;
630
631 enc = &ost->st->codec;
632
633 if (ost->audio_resample) {
634 buftmp = audio_buf;
635 size_out = audio_resample(ost->resample,
636 (short *)buftmp, (short *)buf,
637 size / (ist->st->codec.channels * 2));
638 size_out = size_out * enc->channels * 2;
639 } else {
640 buftmp = buf;
641 size_out = size;
642 }
643
644 /* now encode as many frames as possible */
645 if (enc->codec_id != CODEC_ID_PCM) {
646 /* output resampled raw samples */
647 fifo_write(&ost->fifo, buftmp, size_out,
648 &ost->fifo.wptr);
649
650 frame_bytes = enc->frame_size * 2 * enc->channels;
651
652 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
653 &ost->fifo.rptr) == 0) {
654 ret = avcodec_encode_audio(enc,
655 audio_out, sizeof(audio_out), (short *)audio_buf);
656 s->format->write_packet(s, ost->index, audio_out, ret);
657 }
658 } else {
659 /* XXX: handle endianness */
660 s->format->write_packet(s, ost->index, buftmp, size_out);
661 }
662}
663
664/* write a picture to a raw mux */
665static void write_picture(AVFormatContext *s, int index, AVPicture *picture, int w, int h)
666{
667 UINT8 *buf, *src, *dest;
668 int size, j, i;
669 /* XXX: not efficient, should add test if we can take
670 directly the AVPicture */
671 size = (w * h) * 3 / 2;
672 buf = malloc(size);
673 dest = buf;
674 for(i=0;i<3;i++) {
675 if (i == 1) {
676 w >>= 1;
677 h >>= 1;
678 }
679 src = picture->data[i];
680 for(j=0;j<h;j++) {
681 memcpy(dest, src, w);
682 dest += w;
683 src += picture->linesize[i];
684 }
685 }
686 s->format->write_packet(s, index, buf, size);
687 free(buf);
688}
689
690
691static void do_video_out(AVFormatContext *s,
692 AVOutputStream *ost,
693 AVInputStream *ist,
694 AVPicture *pict)
695{
696 int n1, n2, nb, i, ret, frame_number;
697 AVPicture *picture;
698 UINT8 video_buffer[128*1024];
699 AVCodecContext *enc;
700
701 enc = &ost->st->codec;
702
703 frame_number = ist->frame_number;
704 /* first drop frame if needed */
705 n1 = ((INT64)frame_number * enc->frame_rate) / ist->st->codec.frame_rate;
706 n2 = (((INT64)frame_number + 1) * enc->frame_rate) / ist->st->codec.frame_rate;
707 nb = n2 - n1;
708 if (nb <= 0)
709 return;
710
711 if (ost->video_resample) {
712 picture = &ost->pict_tmp;
713 img_resample(ost->img_resample_ctx, picture, pict);
714 } else {
715 picture = pict;
716 }
717
718 /* duplicates frame if needed */
719 /* XXX: pb because no interleaving */
720 for(i=0;i<nb;i++) {
721 if (enc->codec_id != CODEC_ID_RAWVIDEO) {
722 /* handles sameq here. This is not correct because it may
723 not be a global option */
724 if (same_quality) {
725 ost->st->codec.quality = ist->st->codec.quality;
726 }
727 ret = avcodec_encode_video(&ost->st->codec,
728 video_buffer, sizeof(video_buffer),
729 picture);
730 s->format->write_packet(s, ost->index, video_buffer, ret);
731 } else {
732 write_picture(s, ost->index, picture, enc->width, enc->height);
733 }
734 }
735}
736
737//#define HEX_DUMP
738
739#ifdef HEX_DUMP
740static void hex_dump(UINT8 *buf, int size)
741{
742 int len, i, j, c;
743
744 for(i=0;i<size;i+=16) {
745 len = size - i;
746 if (len > 16)
747 len = 16;
748 printf("%08x ", i);
749 for(j=0;j<16;j++) {
750 if (j < len)
751 printf(" %02x", buf[i+j]);
752 else
753 printf(" ");
754 }
755 printf(" ");
756 for(j=0;j<len;j++) {
757 c = buf[i+j];
758 if (c < ' ' || c > '~')
759 c = '.';
760 printf("%c", c);
761 }
762 printf("\n");
763 }
764}
765#endif
766
767/*
768 * The following code is the main loop of the file converter
769 */
770static int av_encode(AVFormatContext **output_files,
771 int nb_output_files,
772 AVFormatContext **input_files,
773 int nb_input_files,
774 AVStreamMap *stream_maps, int nb_stream_maps)
775{
776 int ret, i, j, k, n, nb_istreams, nb_ostreams = 0;
777 AVFormatContext *is, *os;
778 AVCodecContext *codec, *icodec;
779 AVOutputStream *ost, **ost_table = NULL;
780 AVInputStream *ist, **ist_table = NULL;
781 INT64 min_pts, start_time;
782 AVInputFile file_table[nb_input_files];
783
784 memset(file_table, 0, sizeof(file_table));
785
786 /* input stream init */
787 j = 0;
788 for(i=0;i<nb_input_files;i++) {
789 is = input_files[i];
790 file_table[i].ist_index = j;
791 j += is->nb_streams;
792 }
793 nb_istreams = j;
794
795 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
796 if (!ist_table)
797 return -ENOMEM;
798
799 for(i=0;i<nb_istreams;i++) {
800 ist = av_mallocz(sizeof(AVInputStream));
801 if (!ist)
802 goto fail;
803 ist_table[i] = ist;
804 }
805 j = 0;
806 for(i=0;i<nb_input_files;i++) {
807 is = input_files[i];
808 for(k=0;k<is->nb_streams;k++) {
809 ist = ist_table[j++];
810 ist->st = is->streams[k];
811 ist->file_index = i;
812 ist->index = k;
813 ist->discard = 1; /* the stream is discarded by default
814 (changed later) */
815 }
816 }
817
818 /* output stream init */
819 nb_ostreams = 0;
820 for(i=0;i<nb_output_files;i++) {
821 os = output_files[i];
822 nb_ostreams += os->nb_streams;
823 }
824 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
825 fprintf(stderr, "Number of stream maps must match number of output streams\n");
826 exit(1);
827 }
828
829 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
830 if (!ost_table)
831 goto fail;
832 for(i=0;i<nb_ostreams;i++) {
833 ost = av_mallocz(sizeof(AVOutputStream));
834 if (!ost)
835 goto fail;
836 ost_table[i] = ost;
837 }
838
839 n = 0;
840 for(k=0;k<nb_output_files;k++) {
841 os = output_files[k];
842 for(i=0;i<os->nb_streams;i++) {
843 int found;
844 ost = ost_table[n++];
845 ost->file_index = k;
846 ost->index = i;
847 ost->st = os->streams[i];
848 if (nb_stream_maps > 0) {
849 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
850 stream_maps[n-1].stream_index;
851 } else {
852 /* get corresponding input stream index : we select the first one with the right type */
853 found = 0;
854 for(j=0;j<nb_istreams;j++) {
855 ist = ist_table[j];
856 if (ist->discard &&
857 ist->st->codec.codec_type == ost->st->codec.codec_type) {
858 ost->source_index = j;
859 found = 1;
860 }
861 }
862
863 if (!found) {
864 /* try again and reuse existing stream */
865 for(j=0;j<nb_istreams;j++) {
866 ist = ist_table[j];
867 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
868 ost->source_index = j;
869 found = 1;
870 }
871 }
872 if (!found) {
873 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
874 ost->file_index, ost->index);
875 exit(1);
876 }
877 }
878 }
879 ist = ist_table[ost->source_index];
880 ist->discard = 0;
881 }
882 }
883
884 /* dump the stream mapping */
885 fprintf(stderr, "Stream mapping:\n");
886 for(i=0;i<nb_ostreams;i++) {
887 ost = ost_table[i];
888 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
889 ist_table[ost->source_index]->file_index,
890 ist_table[ost->source_index]->index,
891 ost->file_index,
892 ost->index);
893 }
894
895 /* for each output stream, we compute the right encoding parameters */
896 for(i=0;i<nb_ostreams;i++) {
897 ost = ost_table[i];
898 ist = ist_table[ost->source_index];
899
900 codec = &ost->st->codec;
901 icodec = &ist->st->codec;
902
903 switch(codec->codec_type) {
904 case CODEC_TYPE_AUDIO:
905 /* check if same codec with same parameters. If so, no
906 reencoding is needed */
907 if (codec->codec_id == icodec->codec_id &&
908 codec->bit_rate == icodec->bit_rate &&
909 codec->sample_rate == icodec->sample_rate &&
910 codec->channels == icodec->channels) {
911 /* no reencoding */
912 } else {
913 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
914 goto fail;
915
916 if (codec->channels == icodec->channels &&
917 codec->sample_rate == icodec->sample_rate) {
918 ost->audio_resample = 0;
919 } else {
920 ost->audio_resample = 1;
921 ost->resample = audio_resample_init(codec->channels, icodec->channels,
922 codec->sample_rate,
923 icodec->sample_rate);
924 }
925 ist->decoding_needed = 1;
926 ost->encoding_needed = 1;
927 }
928 break;
929 case CODEC_TYPE_VIDEO:
930 /* check if same codec with same parameters. If so, no
931 reencoding is needed */
932 if (codec->codec_id == icodec->codec_id &&
933 codec->bit_rate == icodec->bit_rate &&
934 codec->frame_rate == icodec->frame_rate &&
935 codec->width == icodec->width &&
936 codec->height == icodec->height) {
937 /* no reencoding */
938 } else {
939 if (codec->width == icodec->width &&
940 codec->height == icodec->height) {
941 ost->video_resample = 0;
942 } else {
943 UINT8 *buf;
944 ost->video_resample = 1;
945 buf = malloc((codec->width * codec->height * 3) / 2);
946 if (!buf)
947 goto fail;
948 ost->pict_tmp.data[0] = buf;
949 ost->pict_tmp.data[1] = ost->pict_tmp.data[0] + (codec->width * codec->height);
950 ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (codec->width * codec->height) / 4;
951 ost->pict_tmp.linesize[0] = codec->width;
952 ost->pict_tmp.linesize[1] = codec->width / 2;
953 ost->pict_tmp.linesize[2] = codec->width / 2;
954
955 ost->img_resample_ctx = img_resample_init(
956 ost->st->codec.width, ost->st->codec.height,
957 ist->st->codec.width, ist->st->codec.height);
958 }
959 ost->encoding_needed = 1;
960 ist->decoding_needed = 1;
961 }
962 break;
963 }
964 }
965
966 /* open each encoder */
967 for(i=0;i<nb_ostreams;i++) {
968 ost = ost_table[i];
969 if (ost->encoding_needed) {
970 AVCodec *codec;
971 codec = avcodec_find_encoder(ost->st->codec.codec_id);
972 if (!codec) {
973 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
974 ost->file_index, ost->index);
975 exit(1);
976 }
977 if (avcodec_open(&ost->st->codec, codec) < 0) {
978 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
979 ost->file_index, ost->index);
980 exit(1);
981 }
982 }
983 }
984
985 /* open each decoder */
986 for(i=0;i<nb_istreams;i++) {
987 ist = ist_table[i];
988 if (ist->decoding_needed) {
989 AVCodec *codec;
990 codec = avcodec_find_decoder(ist->st->codec.codec_id);
991 if (!codec) {
992 fprintf(stderr, "Unsupported codec for input stream #%d.%d\n",
993 ist->file_index, ist->index);
994 exit(1);
995 }
996 if (avcodec_open(&ist->st->codec, codec) < 0) {
997 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
998 ist->file_index, ist->index);
999 exit(1);
1000 }
1001 }
1002 }
1003
1004 /* init pts */
1005 for(i=0;i<nb_istreams;i++) {
1006 ist = ist_table[i];
1007 ist->pts = 0;
1008 ist->frame_number = 0;
1009 }
1010
1011 /* compute buffer size max (should use a complete heuristic) */
1012 for(i=0;i<nb_input_files;i++) {
1013 file_table[i].buffer_size_max = 2048;
1014 }
1015
1016 /* open files and write file headers */
1017 for(i=0;i<nb_output_files;i++) {
1018 os = output_files[i];
1019 os->format->write_header(os);
1020 }
1021
1022 start_time = gettime();
1023 min_pts = 0;
1024 for(;;) {
1025 int file_index, ist_index;
1026 AVPacket pkt;
1027 UINT8 *ptr;
1028 int len;
1029 UINT8 *data_buf;
1030 int data_size, got_picture;
1031 AVPicture picture;
1032 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
1033
1034 /* select the input file with the smallest pts */
1035 redo:
1036 file_index = -1;
1037 min_pts = (1ULL << 63) - 1;
1038 for(i=0;i<nb_istreams;i++) {
1039 ist = ist_table[i];
1040 if (!ist->discard && !file_table[ist->file_index].eof_reached && ist->pts < min_pts) {
1041 min_pts = ist->pts;
1042 file_index = ist->file_index;
1043 }
1044 }
1045 /* if none, if is finished */
1046 if (file_index < 0)
1047 break;
1048 /* finish if recording time exhausted */
1049 if (recording_time > 0 && min_pts >= recording_time)
1050 break;
1051 /* read a packet from it and output it in the fifo */
1052
1053 is = input_files[file_index];
1054 if (av_read_packet(is, &pkt) < 0) {
1055 file_table[file_index].eof_reached = 1;
1056 continue;
1057 }
1058 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1059 ist = ist_table[ist_index];
1060 if (ist->discard) {
1061 continue;
1062 }
1063
1064#ifdef HEX_DUMP
1065 printf("stream #%d, size=%d:\n", pkt.stream_index, pkt.size);
1066 hex_dump(pkt.data, pkt.size);
1067#endif
1068
1069 // printf("read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1070
1071 len = pkt.size;
1072 ptr = pkt.data;
1073 while (len > 0) {
1074
1075 /* decode the packet if needed */
1076 data_buf = NULL; /* fail safe */
1077 data_size = 0;
1078 if (ist->decoding_needed) {
1079 switch(ist->st->codec.codec_type) {
1080 case CODEC_TYPE_AUDIO:
1081 if (ist->st->codec.codec_id == CODEC_ID_PCM) {
1082 /* no need to call a codec */
1083 data_buf = ptr;
1084 data_size = len;
1085 ret = len;
1086 } else {
1087 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1088 ptr, len);
1089 if (ret < 0)
1090 goto fail_decode;
1091 if (data_size == 0) {
1092 /* no audio frame */
1093 ptr += ret;
1094 len -= ret;
1095 continue;
1096 }
1097 data_buf = (UINT8 *)samples;
1098 }
1099 break;
1100 case CODEC_TYPE_VIDEO:
1101 if (ist->st->codec.codec_id == CODEC_ID_RAWVIDEO) {
1102 int size;
1103 size = (ist->st->codec.width * ist->st->codec.height);
1104
1105 picture.data[0] = ptr;
1106 picture.data[1] = picture.data[0] + size;
1107 picture.data[2] = picture.data[1] + size / 4;
1108 picture.linesize[0] = ist->st->codec.width;
1109 picture.linesize[1] = ist->st->codec.width / 2;
1110 picture.linesize[2] = ist->st->codec.width / 2;
1111 ret = len;
1112 } else {
1113 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1114 ret = avcodec_decode_video(&ist->st->codec,
1115 &picture, &got_picture, ptr, len);
1116 if (ret < 0) {
1117 fail_decode:
1118 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1119 ist->file_index, ist->index);
1120 av_free_packet(&pkt);
1121 goto redo;
1122 }
1123 if (!got_picture) {
1124 /* no picture yet */
1125 ptr += ret;
1126 len -= ret;
1127 continue;
1128 }
1129 }
1130 break;
1131 default:
1132 goto fail_decode;
1133 }
1134 } else {
1135 data_buf = ptr;
1136 data_size = len;
1137 ret = len;
1138 }
1139 /* update pts */
1140 switch(ist->st->codec.codec_type) {
1141 case CODEC_TYPE_AUDIO:
1142 ist->pts = (INT64)1000000 * ist->sample_index / ist->st->codec.sample_rate;
1143 ist->sample_index += data_size / (2 * ist->st->codec.channels);
1144 break;
1145 case CODEC_TYPE_VIDEO:
1146 ist->frame_number++;
1147 ist->pts = ((INT64)ist->frame_number * 1000000 * FRAME_RATE_BASE) /
1148 ist->st->codec.frame_rate;
1149 break;
1150 }
1151 ptr += ret;
1152 len -= ret;
1153
1154 /* transcode raw format, encode packets and output them */
1155
1156 for(i=0;i<nb_ostreams;i++) {
1157 ost = ost_table[i];
1158 if (ost->source_index == ist_index) {
1159 os = output_files[ost->file_index];
1160
1161 if (ost->encoding_needed) {
1162 switch(ost->st->codec.codec_type) {
1163 case CODEC_TYPE_AUDIO:
1164 do_audio_out(os, ost, ist, data_buf, data_size);
1165 break;
1166 case CODEC_TYPE_VIDEO:
1167 do_video_out(os, ost, ist, &picture);
1168 break;
1169 }
1170 } else {
1171 /* no reencoding needed : output the packet directly */
1172 os->format->write_packet(os, ost->index, data_buf, data_size);
1173 }
1174 }
1175 }
1176 }
1177 av_free_packet(&pkt);
1178
1179 /* dump report by using the first video and audio streams */
1180 {
1181 char buf[1024];
1182 AVFormatContext *oc;
1183 INT64 total_size, ti;
1184 AVCodecContext *enc;
1185 int frame_number, vid;
1186 double bitrate, ti1;
1187 static INT64 last_time;
1188
1189 if ((min_pts - last_time) >= 500000) {
1190 last_time = min_pts;
1191
1192 oc = output_files[0];
1193
1194 total_size = url_ftell(&oc->pb);
1195
1196 buf[0] = '\0';
1197 ti = (1ULL << 63) - 1;
1198 vid = 0;
1199 for(i=0;i<nb_ostreams;i++) {
1200 ost = ost_table[i];
1201 enc = &ost->st->codec;
1202 ist = ist_table[ost->source_index];
1203 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1204 frame_number = ist->frame_number;
1205 sprintf(buf + strlen(buf), "frame=%5d q=%2d ",
1206 frame_number, enc->quality);
1207 vid = 1;
1208 }
1209 /* compute min pts value */
1210 if (!ist->discard && ist->pts < ti) {
1211 ti = ist->pts;
1212 }
1213 }
1214
1215 ti1 = ti / 1000000.0;
1216 if (ti1 < 0.1)
1217 ti1 = 0.1;
1218 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1219
1220 sprintf(buf + strlen(buf), "size=%8LdkB time=%0.1f bitrate=%6.1fkbits/s",
1221 total_size / 1024, ti1, bitrate);
1222
1223 fprintf(stderr, "%s \r", buf);
1224 fflush(stderr);
1225 }
1226 }
1227 }
1228
1229 /* dump report by using the first video and audio streams */
1230 {
1231 char buf[1024];
1232 AVFormatContext *oc;
1233 INT64 total_size, ti;
1234 AVCodecContext *enc;
1235 int frame_number, vid;
1236 double bitrate, ti1;
1237
1238 oc = output_files[0];
1239
1240 total_size = url_ftell(&oc->pb);
1241
1242 buf[0] = '\0';
1243 ti = (1ULL << 63) - 1;
1244 vid = 0;
1245 for(i=0;i<nb_ostreams;i++) {
1246 ost = ost_table[i];
1247 enc = &ost->st->codec;
1248 ist = ist_table[ost->source_index];
1249 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1250 frame_number = ist->frame_number;
1251 sprintf(buf + strlen(buf), "frame=%5d q=%2d ",
1252 frame_number, enc->quality);
1253 vid = 1;
1254 }
1255 /* compute min pts value */
1256 if (!ist->discard && ist->pts < ti) {
1257 ti = ist->pts;
1258 }
1259 }
1260
1261 ti1 = ti / 1000000.0;
1262 if (ti1 < 0.1)
1263 ti1 = 0.1;
1264 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1265
1266 sprintf(buf + strlen(buf), "size=%8LdkB time=%0.1f bitrate=%6.1fkbits/s",
1267 total_size / 1024, ti1, bitrate);
1268
1269 fprintf(stderr, "%s \n", buf);
1270 }
1271 /* close each encoder */
1272 for(i=0;i<nb_ostreams;i++) {
1273 ost = ost_table[i];
1274 if (ost->encoding_needed) {
1275 avcodec_close(&ost->st->codec);
1276 }
1277 }
1278
1279 /* close each decoder */
1280 for(i=0;i<nb_istreams;i++) {
1281 ist = ist_table[i];
1282 if (ist->decoding_needed) {
1283 avcodec_close(&ist->st->codec);
1284 }
1285 }
1286
1287
1288 /* write the trailer if needed and close file */
1289 for(i=0;i<nb_output_files;i++) {
1290 os = output_files[i];
1291 os->format->write_trailer(os);
1292 }
1293 /* finished ! */
1294
1295 ret = 0;
1296 fail1:
1297 if (ist_table) {
1298 for(i=0;i<nb_istreams;i++) {
1299 ist = ist_table[i];
1300 if (ist) {
1301 free(ist);
1302 }
1303 }
1304 free(ist_table);
1305 }
1306 if (ost_table) {
1307 for(i=0;i<nb_ostreams;i++) {
1308 ost = ost_table[i];
1309 if (ost) {
1310 if (ost->pict_tmp.data[0])
1311 free(ost->pict_tmp.data[0]);
1312 if (ost->video_resample)
1313 img_resample_close(ost->img_resample_ctx);
1314 if (ost->audio_resample)
1315 audio_resample_close(ost->resample);
1316 free(ost);
1317 }
1318 }
1319 free(ost_table);
1320 }
1321 return ret;
1322 fail:
1323 ret = -ENOMEM;
1324 goto fail1;
1325}
1326
1327#if 0
1328int file_read(const char *filename)
1329{
1330 URLContext *h;
1331 unsigned char buffer[1024];
1332 int len, i;
1333
1334 if (url_open(&h, filename, O_RDONLY) < 0) {
1335 printf("could not open '%s'\n", filename);
1336 return -1;
1337 }
1338 for(;;) {
1339 len = url_read(h, buffer, sizeof(buffer));
1340 if (len <= 0)
1341 break;
1342 for(i=0;i<len;i++) putchar(buffer[i]);
1343 }
1344 url_close(h);
1345 return 0;
1346}
1347#endif
1348
1349void show_licence(void)
1350{
1351 printf(
1352 "ffmpeg version " FFMPEG_VERSION "\n"
1353 "Copyright (c) 2000,2001 Gerard Lantau\n"
1354 "This program is free software; you can redistribute it and/or modify\n"
1355 "it under the terms of the GNU General Public License as published by\n"
1356 "the Free Software Foundation; either version 2 of the License, or\n"
1357 "(at your option) any later version.\n"
1358 "\n"
1359 "This program is distributed in the hope that it will be useful,\n"
1360 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1361 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1362 "GNU General Public License for more details.\n"
1363 "\n"
1364 "You should have received a copy of the GNU General Public License\n"
1365 "along with this program; if not, write to the Free Software\n"
1366 "Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n"
1367 );
1368 exit(1);
1369}
1370
1371void opt_format(const char *arg)
1372{
1373 AVFormat *f;
1374 f = first_format;
1375 while (f != NULL && strcmp(f->name, arg) != 0) f = f->next;
1376 if (f == NULL) {
1377 fprintf(stderr, "Invalid format: %s\n", arg);
1378 exit(1);
1379 }
1380 file_format = f;
1381}
1382
1383void opt_video_bitrate(const char *arg)
1384{
1385 video_bit_rate = atoi(arg) * 1000;
1386}
1387
1388void opt_frame_rate(const char *arg)
1389{
1390 frame_rate = (int)(strtod(arg, 0) * FRAME_RATE_BASE);
1391}
1392
1393void opt_frame_size(const char *arg)
1394{
1395 parse_image_size(&frame_width, &frame_height, arg);
1396 if (frame_width <= 0 || frame_height <= 0) {
1397 fprintf(stderr, "Incorrect frame size\n");
1398 exit(1);
1399 }
1400 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
1401 fprintf(stderr, "Frame size must be a multiple of 2\n");
1402 exit(1);
1403 }
1404}
1405
1406void opt_gop_size(const char *arg)
1407{
1408 gop_size = atoi(arg);
1409}
1410
1411void opt_qscale(const char *arg)
1412{
1413 video_qscale = atoi(arg);
1414 if (video_qscale < 0 ||
1415 video_qscale > 31) {
1416 fprintf(stderr, "qscale must be >= 1 and <= 31\n");
1417 exit(1);
1418 }
1419}
1420
1421
1422void opt_audio_bitrate(const char *arg)
1423{
1424 audio_bit_rate = atoi(arg) * 1000;
1425}
1426
1427void opt_audio_rate(const char *arg)
1428{
1429 audio_sample_rate = atoi(arg);
1430}
1431
1432void opt_audio_channels(const char *arg)
1433{
1434 audio_channels = atoi(arg);
1435}
1436
1437void opt_video_device(const char *arg)
1438{
1439 v4l_device = strdup(arg);
1440}
1441
1442void opt_audio_device(const char *arg)
1443{
1444 audio_device = strdup(arg);
1445}
1446
1447void opt_audio_codec(const char *arg)
1448{
1449 AVCodec *p;
1450
1451 p = first_avcodec;
1452 while (p) {
1453 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
1454 break;
1455 p = p->next;
1456 }
1457 if (p == NULL) {
1458 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
1459 exit(1);
1460 } else {
1461 audio_codec_id = p->id;
1462 }
1463}
1464
1465const char *motion_str[] = {
1466 "zero",
1467 "full",
1468 "log",
1469 "phods",
1470 NULL,
1471};
1472
1473void opt_motion_estimation(const char *arg)
1474{
1475 const char **p;
1476 p = motion_str;
1477 for(;;) {
1478 if (!*p) {
1479 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
1480 exit(1);
1481 }
1482 if (!strcmp(*p, arg))
1483 break;
1484 p++;
1485 }
1486 motion_estimation_method = p - motion_str;
1487}
1488
1489void opt_video_codec(const char *arg)
1490{
1491 AVCodec *p;
1492
1493 p = first_avcodec;
1494 while (p) {
1495 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
1496 break;
1497 p = p->next;
1498 }
1499 if (p == NULL) {
1500 fprintf(stderr, "Unknown video codec '%s'\n", arg);
1501 exit(1);
1502 } else {
1503 video_codec_id = p->id;
1504 }
1505}
1506
1507void opt_map(const char *arg)
1508{
1509 AVStreamMap *m;
1510 const char *p;
1511
1512 p = arg;
1513 m = &stream_maps[nb_stream_maps++];
1514
1515 m->file_index = strtol(arg, (char **)&p, 0);
1516 if (*p)
1517 p++;
1518 m->stream_index = strtol(arg, (char **)&p, 0);
1519}
1520
1521void opt_recording_time(const char *arg)
1522{
1523 recording_time = parse_date(arg, 1);
1524}
1525
1526/* return the number of packet read to find the codec parameters */
1527int find_codec_parameters(AVFormatContext *ic)
1528{
1529 int val, i, count, ret, got_picture, size;
1530 AVCodec *codec;
1531 AVCodecContext *enc;
1532 AVStream *st;
1533 AVPacket *pkt;
1534 AVPicture picture;
1535 AVPacketList *pktl, **ppktl;
1536 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
1537 UINT8 *ptr;
1538
1539 count = 0;
1540 ppktl = &ic->packet_buffer;
1541 for(;;) {
1542 for(i=0;i<ic->nb_streams;i++) {
1543 enc = &ic->streams[i]->codec;
1544
1545 switch(enc->codec_type) {
1546 case CODEC_TYPE_AUDIO:
1547 val = enc->sample_rate;
1548 break;
1549 case CODEC_TYPE_VIDEO:
1550 val = enc->width;
1551 break;
1552 default:
1553 val = 1;
1554 break;
1555 }
1556 /* if no parameters supplied, then we should read it from
1557 the stream */
1558 if (val == 0)
1559 break;
1560 }
1561 if (i == ic->nb_streams) {
1562 ret = count;
1563 break;
1564 }
1565
1566 if (count == 0) {
1567 /* open each codec */
1568 for(i=0;i<ic->nb_streams;i++) {
1569 st = ic->streams[i];
1570 codec = avcodec_find_decoder(st->codec.codec_id);
1571 if (codec == NULL) {
1572 ret = -1;
1573 goto the_end;
1574 }
1575 avcodec_open(&st->codec, codec);
1576 }
1577 }
1578 pktl = av_mallocz(sizeof(AVPacketList));
1579 if (!pktl) {
1580 ret = -1;
1581 break;
1582 }
1583
1584 /* add the packet in the buffered packet list */
1585 *ppktl = pktl;
1586 ppktl = &pktl->next;
1587
1588 pkt = &pktl->pkt;
1589 if (ic->format->read_packet(ic, pkt) < 0) {
1590 ret = -1;
1591 break;
1592 }
1593 st = ic->streams[pkt->stream_index];
1594
1595 /* decode the data and update codec parameters */
1596 ptr = pkt->data;
1597 size = pkt->size;
1598 while (size > 0) {
1599 switch(st->codec.codec_type) {
1600 case CODEC_TYPE_VIDEO:
1601 ret = avcodec_decode_video(&st->codec, &picture, &got_picture, ptr, size);
1602 break;
1603 case CODEC_TYPE_AUDIO:
1604 ret = avcodec_decode_audio(&st->codec, samples, &got_picture, ptr, size);
1605 break;
1606 default:
1607 ret = -1;
1608 break;
1609 }
1610 if (ret < 0) {
1611 ret = -1;
1612 goto the_end;
1613 }
1614 if (got_picture)
1615 break;
1616 ptr += ret;
1617 size -= ret;
1618 }
1619
1620 count++;
1621 }
1622 the_end:
1623 if (count > 0) {
1624 /* close each codec */
1625 for(i=0;i<ic->nb_streams;i++) {
1626 st = ic->streams[i];
1627 avcodec_close(&st->codec);
1628 }
1629 }
1630 return ret;
1631}
1632
1633
1634void opt_input_file(const char *filename)
1635{
1636 AVFormatContext *ic;
1637 AVFormatParameters params, *ap = &params;
1638 URLFormat url_format;
1639 AVFormat *fmt;
1640 int err, i, ret;
1641
1642 ic = av_mallocz(sizeof(AVFormatContext));
1643 strcpy(ic->filename, filename);
1644 /* first format guess to know if we must open file */
1645 fmt = file_format;
1646 if (!fmt)
1647 fmt = guess_format(NULL, filename, NULL);
1648
1649 if (fmt == NULL || !(fmt->flags & AVFMT_NOFILE)) {
1650 /* open file */
1651 if (url_fopen(&ic->pb, filename, URL_RDONLY) < 0) {
1652 fprintf(stderr, "Could not open '%s'\n", filename);
1653 exit(1);
1654 }
1655
1656 /* find format and set default parameters */
1657 fmt = file_format;
1658 err = url_getformat(url_fileno(&ic->pb), &url_format);
1659 if (err >= 0) {
1660 if (!fmt)
1661 fmt = guess_format(url_format.format_name, NULL, NULL);
1662 ap->sample_rate = url_format.sample_rate;
1663 ap->frame_rate = url_format.frame_rate;
1664 ap->channels = url_format.channels;
1665 ap->width = url_format.width;
1666 ap->height = url_format.height;
1667 ap->pix_fmt = url_format.pix_fmt;
1668 } else {
1669 if (!fmt)
1670 fmt = guess_format(NULL, filename, NULL);
1671 memset(ap, 0, sizeof(*ap));
1672 }
1673 } else {
1674 memset(ap, 0, sizeof(*ap));
1675 }
1676
1677 if (!fmt || !fmt->read_header) {
1678 fprintf(stderr, "%s: Unknown file format\n", filename);
1679 exit(1);
1680 }
1681 ic->format = fmt;
1682
1683 /* get default parameters from command line */
1684 if (!ap->sample_rate)
1685 ap->sample_rate = audio_sample_rate;
1686 if (!ap->channels)
1687 ap->channels = audio_channels;
1688
1689 if (!ap->frame_rate)
1690 ap->frame_rate = frame_rate;
1691 if (!ap->width)
1692 ap->width = frame_width;
1693 if (!ap->height)
1694 ap->height = frame_height;
1695
1696 err = ic->format->read_header(ic, ap);
1697 if (err < 0) {
1698 fprintf(stderr, "%s: Error while parsing header\n", filename);
1699 exit(1);
1700 }
1701
1702 /* If not enough info for the codecs, we decode the first frames
1703 to get it. (used in mpeg case for example) */
1704 ret = find_codec_parameters(ic);
1705 if (ret < 0) {
1706 fprintf(stderr, "%s: could not find codec parameters\n", filename);
1707 exit(1);
1708 }
1709
1710 /* update the current parameters so that they match the one of the input stream */
1711 for(i=0;i<ic->nb_streams;i++) {
1712 AVCodecContext *enc = &ic->streams[i]->codec;
1713 switch(enc->codec_type) {
1714 case CODEC_TYPE_AUDIO:
1715 audio_channels = enc->channels;
1716 audio_sample_rate = enc->sample_rate;
1717 break;
1718 case CODEC_TYPE_VIDEO:
1719 frame_height = enc->height;
1720 frame_width = enc->width;
1721 frame_rate = enc->frame_rate;
1722 break;
1723 }
1724 }
1725
1726 input_files[nb_input_files] = ic;
1727 /* dump the file content */
1728 dump_format(ic, nb_input_files, filename, 0);
1729 nb_input_files++;
1730 file_format = NULL;
1731}
1732
1733void opt_output_file(const char *filename)
1734{
1735 AVStream *st;
1736 AVFormatContext *oc;
1737 int use_video, use_audio, nb_streams;
1738 int codec_id;
1739
1740 if (!strcmp(filename, "-"))
1741 filename = "pipe:";
1742
1743 oc = av_mallocz(sizeof(AVFormatContext));
1744
1745 if (!file_format) {
1746 file_format = guess_format(NULL, filename, NULL);
1747 if (!file_format)
1748 file_format = &mpeg_mux_format;
1749 }
1750
1751 oc->format = file_format;
1752
1753 if (!strcmp(file_format->name, "ffm") &&
1754 strstart(filename, "http:", NULL)) {
1755 /* special case for files sent to ffserver: we get the stream
1756 parameters from ffserver */
1757 if (read_ffserver_streams(oc, filename) < 0) {
1758 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
1759 exit(1);
1760 }
1761 } else {
1762 use_video = file_format->video_codec != CODEC_ID_NONE;
1763 use_audio = file_format->audio_codec != CODEC_ID_NONE;
1764
1765 if (audio_disable) {
1766 use_audio = 0;
1767 }
1768 if (video_disable) {
1769 use_video = 0;
1770 }
1771
1772 nb_streams = 0;
1773 if (use_video) {
1774 AVCodecContext *video_enc;
1775
1776 st = av_mallocz(sizeof(AVStream));
1777 if (!st) {
1778 fprintf(stderr, "Could not alloc stream\n");
1779 exit(1);
1780 }
1781 video_enc = &st->codec;
1782
1783 codec_id = file_format->video_codec;
1784 if (video_codec_id != CODEC_ID_NONE)
1785 codec_id = video_codec_id;
1786
1787 video_enc->codec_id = codec_id;
1788 video_enc->codec_type = CODEC_TYPE_VIDEO;
1789
1790 video_enc->bit_rate = video_bit_rate;
1791 video_enc->frame_rate = frame_rate;
1792
1793 video_enc->width = frame_width;
1794 video_enc->height = frame_height;
1795 if (!intra_only)
1796 video_enc->gop_size = gop_size;
1797 else
1798 video_enc->gop_size = 0;
1799 if (video_qscale || same_quality) {
1800 video_enc->flags |= CODEC_FLAG_QSCALE;
1801 video_enc->quality = video_qscale;
1802 }
1803
1804 oc->streams[nb_streams] = st;
1805 nb_streams++;
1806 }
1807
1808 if (use_audio) {
1809 AVCodecContext *audio_enc;
1810
1811 st = av_mallocz(sizeof(AVStream));
1812 if (!st) {
1813 fprintf(stderr, "Could not alloc stream\n");
1814 exit(1);
1815 }
1816 audio_enc = &st->codec;
1817 codec_id = file_format->audio_codec;
1818 if (audio_codec_id != CODEC_ID_NONE)
1819 codec_id = audio_codec_id;
1820 audio_enc->codec_id = codec_id;
1821 audio_enc->codec_type = CODEC_TYPE_AUDIO;
1822
1823 audio_enc->bit_rate = audio_bit_rate;
1824 audio_enc->sample_rate = audio_sample_rate;
1825 audio_enc->channels = audio_channels;
1826 oc->streams[nb_streams] = st;
1827 nb_streams++;
1828 }
1829
1830 oc->nb_streams = nb_streams;
1831
1832 if (!nb_streams) {
1833 fprintf(stderr, "No audio or video selected\n");
1834 exit(1);
1835 }
1836
1837 if (str_title)
1838 nstrcpy(oc->title, sizeof(oc->title), str_title);
1839 if (str_author)
1840 nstrcpy(oc->author, sizeof(oc->author), str_author);
1841 if (str_copyright)
1842 nstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
1843 if (str_comment)
1844 nstrcpy(oc->comment, sizeof(oc->comment), str_comment);
1845 }
1846
1847 output_files[nb_output_files] = oc;
1848 /* dump the file content */
1849 dump_format(oc, nb_output_files, filename, 1);
1850 nb_output_files++;
1851
1852 strcpy(oc->filename, filename);
1853 if (!(oc->format->flags & AVFMT_NOFILE)) {
1854 /* test if it already exists to avoid loosing precious files */
1855 if (!file_overwrite &&
1856 (strchr(filename, ':') == NULL ||
1857 strstart(filename, "file:", NULL))) {
1858 if (url_exist(filename)) {
1859 int c;
1860
1861 printf("File '%s' already exists. Overwrite ? [y/N] ", filename);
1862 fflush(stdout);
1863 c = getchar();
1864 if (toupper(c) != 'Y') {
1865 fprintf(stderr, "Not overwriting - exiting\n");
1866 exit(1);
1867 }
1868 }
1869 }
1870
1871 /* open the file */
1872 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
1873 fprintf(stderr, "Could not open '%s'\n", filename);
1874 exit(1);
1875 }
1876 }
1877
1878 /* reset some options */
1879 file_format = NULL;
1880 audio_disable = 0;
1881 video_disable = 0;
1882 audio_codec_id = CODEC_ID_NONE;
1883 video_codec_id = CODEC_ID_NONE;
1884}
1885
5727b222
FB
1886INT64 getutime(void)
1887{
1888 struct rusage rusage;
1889
1890 getrusage(RUSAGE_SELF, &rusage);
1891 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
1892}
1893
85f07f22
FB
1894void show_formats(void)
1895{
1896 AVFormat *f;
1897 URLProtocol *up;
1898 AVCodec *p;
1899 const char **pp;
1900
1901 printf("File formats:\n");
1902 printf(" Encoding:");
1903 for(f = first_format; f != NULL; f = f->next) {
1904 if (f->write_header)
1905 printf(" %s", f->name);
1906 }
1907 printf("\n");
1908 printf(" Decoding:");
1909 for(f = first_format; f != NULL; f = f->next) {
1910 if (f->read_header)
1911 printf(" %s", f->name);
1912 }
1913 printf("\n");
1914
1915 printf("Codecs:\n");
1916 printf(" Encoders:");
1917 for(p = first_avcodec; p != NULL; p = p->next) {
1918 if (p->encode)
1919 printf(" %s", p->name);
1920 }
1921 printf("\n");
1922
1923 printf(" Decoders:");
1924 for(p = first_avcodec; p != NULL; p = p->next) {
1925 if (p->decode)
1926 printf(" %s", p->name);
1927 }
1928 printf("\n");
1929
1930 printf("Supported file protocols:");
1931 for(up = first_protocol; up != NULL; up = up->next)
1932 printf(" %s:", up->name);
1933 printf("\n");
1934
1935 printf("Frame size abbreviations: sqcif qcif cif 4cif\n");
1936 printf("Motion estimation methods:");
1937 pp = motion_str;
1938 while (*pp) {
1939 printf(" %s", *pp);
1940 if ((pp - motion_str) == ME_ZERO)
1941 printf("(fastest)");
1942 else if ((pp - motion_str) == ME_FULL)
1943 printf("(slowest)");
1944 else if ((pp - motion_str) == ME_LOG)
1945 printf("(default)");
1946 pp++;
1947 }
1948 printf("\n");
1949 exit(1);
1950}
1951
1952void show_help(void)
1953{
1954 const OptionDef *po;
1955 int i, expert;
1956
1957 printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000,2001 Gerard Lantau\n"
1958 "usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
1959 "Hyper fast MPEG1/MPEG4/H263/RV and AC3/MPEG audio encoder\n"
1960 "\n"
1961 "Main options are:\n");
1962 for(i=0;i<2;i++) {
1963 if (i == 1)
1964 printf("\nAdvanced options are:\n");
1965 for(po = options; po->name != NULL; po++) {
1966 char buf[64];
1967 expert = (po->flags & OPT_EXPERT) != 0;
1968 if (expert == i) {
1969 strcpy(buf, po->name);
1970 if (po->flags & HAS_ARG) {
1971 strcat(buf, " ");
1972 strcat(buf, po->argname);
1973 }
1974 printf("-%-17s %s\n", buf, po->help);
1975 }
1976 }
1977 }
1978
1979 exit(1);
1980}
1981
1982const OptionDef options[] = {
1983 { "L", 0, {show_licence}, "show license" },
1984 { "h", 0, {show_help}, "show help" },
1985 { "formats", 0, {show_formats}, "show available formats, codecs, protocols, ..." },
1986 { "f", HAS_ARG, {opt_format}, "force format", "fmt" },
1987 { "i", HAS_ARG, {opt_input_file}, "input file name", "filename" },
1988 { "y", OPT_BOOL, {int_arg:&file_overwrite}, "overwrite output files" },
1989 { "map", HAS_ARG | OPT_EXPERT, {opt_map}, "set input stream mapping", "file:stream" },
1990 { "t", HAS_ARG, {opt_recording_time}, "set the recording time", "duration" },
1991 { "title", HAS_ARG | OPT_STRING, {str_arg: &str_title}, "set the title", "string" },
1992 { "author", HAS_ARG | OPT_STRING, {str_arg: &str_author}, "set the author", "string" },
1993 { "copyright", HAS_ARG | OPT_STRING, {str_arg: &str_copyright}, "set the copyright", "string" },
1994 { "comment", HAS_ARG | OPT_STRING, {str_arg: &str_comment}, "set the comment", "string" },
1995 /* video options */
1996 { "b", HAS_ARG, {opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
1997 { "r", HAS_ARG, {opt_frame_rate}, "set frame rate (in Hz)", "rate" },
1998 { "s", HAS_ARG, {opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
1999 { "g", HAS_ARG | OPT_EXPERT, {opt_gop_size}, "set the group of picture size", "gop_size" },
2000 { "intra", OPT_BOOL | OPT_EXPERT, {int_arg: &intra_only}, "use only intra frames"},
2001 { "vn", OPT_BOOL, {int_arg: &video_disable}, "disable video" },
2002 { "qscale", HAS_ARG | OPT_EXPERT, {opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
2003 { "vd", HAS_ARG | OPT_EXPERT, {opt_video_device}, "set video device", "device" },
2004 { "vcodec", HAS_ARG | OPT_EXPERT, {opt_video_codec}, "force video codec", "codec" },
2005 { "me", HAS_ARG | OPT_EXPERT, {opt_motion_estimation}, "set motion estimation method",
2006 "method" },
2007 { "sameq", OPT_BOOL, {int_arg: &same_quality},
2008 "use same video quality as source (implies VBR)" },
2009 /* audio options */
2010 { "ab", HAS_ARG, {opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
2011 { "ar", HAS_ARG, {opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
2012 { "ac", HAS_ARG, {opt_audio_channels}, "set number of audio channels", "channels" },
2013 { "an", OPT_BOOL, {int_arg: &audio_disable}, "disable audio" },
2014 { "ad", HAS_ARG | OPT_EXPERT, {opt_audio_device}, "set audio device", "device" },
2015 { "acodec", HAS_ARG | OPT_EXPERT, {opt_audio_codec}, "force audio codec", "codec" },
5727b222
FB
2016 { "benchmark", OPT_BOOL | OPT_EXPERT, {int_arg: &do_benchmark},
2017 "add timings for benchmarking" },
85f07f22
FB
2018
2019 { NULL, },
2020};
2021
2022int main(int argc, char **argv)
2023{
2024 int optindex, i;
2025 const char *opt, *arg;
2026 const OptionDef *po;
2027
2028 register_all();
2029
2030 if (argc <= 1)
2031 show_help();
2032
2033 optindex = 1;
2034 while (optindex < argc) {
2035 opt = argv[optindex++];
2036
2037 if (opt[0] == '-' && opt[1] != '\0') {
2038 po = options;
2039 while (po->name != NULL) {
2040 if (!strcmp(opt + 1, po->name))
2041 break;
2042 po++;
2043 }
2044 if (!po->name) {
2045 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
2046 exit(1);
2047 }
2048 arg = NULL;
2049 if (po->flags & HAS_ARG)
2050 arg = argv[optindex++];
2051 if (po->flags & OPT_STRING) {
2052 char *str;
2053 str = strdup(arg);
2054 *po->u.str_arg = str;
2055 } else if (po->flags & OPT_BOOL) {
2056 *po->u.int_arg = 1;
2057 } else {
2058 po->u.func_arg(arg);
2059 }
2060 } else {
2061 opt_output_file(opt);
2062 }
2063 }
2064
2065
2066 if (nb_input_files == 0) {
2067 if (nb_output_files != 1) {
2068 fprintf(stderr, "Only one output file supported when grabbing\n");
2069 exit(1);
2070 }
2071 av_grab(output_files[0]);
2072 } else {
5727b222
FB
2073 INT64 ti;
2074
85f07f22
FB
2075 if (nb_output_files <= 0) {
2076 fprintf(stderr, "Must supply at least one output file\n");
2077 exit(1);
2078 }
5727b222 2079 ti = getutime();
85f07f22
FB
2080 av_encode(output_files, nb_output_files, input_files, nb_input_files,
2081 stream_maps, nb_stream_maps);
5727b222
FB
2082 ti = getutime() - ti;
2083 if (do_benchmark) {
2084 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
2085 }
85f07f22
FB
2086 }
2087
2088 /* close files */
2089 for(i=0;i<nb_output_files;i++) {
2090 if (!(output_files[i]->format->flags & AVFMT_NOFILE))
2091 url_fclose(&output_files[i]->pb);
2092 }
2093 for(i=0;i<nb_input_files;i++) {
2094 if (!(input_files[i]->format->flags & AVFMT_NOFILE))
2095 url_fclose(&input_files[i]->pb);
2096 }
2097
2098 return 0;
2099}