* opts compilation
[libav.git] / ffmpeg.c
CommitLineData
85f07f22
FB
1/*
2 * FFmpeg main
bf5af568 3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
85f07f22 4 *
bf5af568
FB
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
85f07f22 9 *
bf5af568 10 * This library is distributed in the hope that it will be useful,
85f07f22 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
bf5af568
FB
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
85f07f22 14 *
bf5af568
FB
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
85f07f22 18 */
daf8e955
FB
19#define HAVE_AV_CONFIG_H
20#include "avformat.h"
10d104e4 21#include "framehook.h"
daf8e955 22
bdc4796f 23#ifndef CONFIG_WIN32
85f07f22
FB
24#include <unistd.h>
25#include <fcntl.h>
26#include <sys/ioctl.h>
85f07f22 27#include <sys/time.h>
85f07f22 28#include <termios.h>
5727b222 29#include <sys/resource.h>
bdc4796f 30#endif
f3ec2d46
SG
31#ifdef CONFIG_OS2
32#include <sys/types.h>
33#include <sys/select.h>
34#include <stdlib.h>
35#endif
bf5af568
FB
36#include <time.h>
37#include <ctype.h>
85f07f22 38
8aa1e3da
MN
39#if !defined(INFINITY) && defined(HUGE_VAL)
40#define INFINITY HUGE_VAL
41#endif
85f07f22 42
bdc4796f
FB
43#define MAXINT64 INT64_C(0x7fffffffffffffff)
44
85f07f22
FB
45typedef struct {
46 const char *name;
47 int flags;
48#define HAS_ARG 0x0001
49#define OPT_BOOL 0x0002
50#define OPT_EXPERT 0x0004
51#define OPT_STRING 0x0008
52 union {
53 void (*func_arg)();
54 int *int_arg;
55 char **str_arg;
56 } u;
57 const char *help;
58 const char *argname;
59} OptionDef;
60
61/* select an input stream for an output stream */
62typedef struct AVStreamMap {
63 int file_index;
64 int stream_index;
65} AVStreamMap;
66
67extern const OptionDef options[];
68
69void show_help(void);
70
71#define MAX_FILES 20
72
73static AVFormatContext *input_files[MAX_FILES];
74static int nb_input_files = 0;
75
76static AVFormatContext *output_files[MAX_FILES];
77static int nb_output_files = 0;
78
79static AVStreamMap stream_maps[MAX_FILES];
80static int nb_stream_maps;
81
79fdaa4c
FB
82static AVInputFormat *file_iformat;
83static AVOutputFormat *file_oformat;
817b23ff 84static AVImageFormat *image_format;
85f07f22
FB
85static int frame_width = 160;
86static int frame_height = 128;
ab6d194a
MN
87static int frame_topBand = 0;
88static int frame_bottomBand = 0;
89static int frame_leftBand = 0;
90static int frame_rightBand = 0;
85f07f22 91static int frame_rate = 25 * FRAME_RATE_BASE;
e47ec515 92extern int emulate_frame_rate;
3aa102be
MN
93static int video_bit_rate = 200*1000;
94static int video_bit_rate_tolerance = 4000*1000;
85f07f22 95static int video_qscale = 0;
3aa102be
MN
96static int video_qmin = 2;
97static int video_qmax = 31;
17a70fde
MN
98static int video_mb_qmin = 2;
99static int video_mb_qmax = 31;
9cdd6a24
MN
100static int video_qdiff = 3;
101static float video_qblur = 0.5;
102static float video_qcomp = 0.5;
ac2830ec 103#if 0 //experimental, (can be removed)
3aa102be
MN
104static float video_rc_qsquish=1.0;
105static float video_rc_qmod_amp=0;
106static int video_rc_qmod_freq=0;
ac2830ec 107#endif
3aa102be
MN
108static char *video_rc_override_string=NULL;
109static char *video_rc_eq="tex^qComp";
110static int video_rc_buffer_size=0;
111static float video_rc_buffer_aggressivity=1.0;
112static int video_rc_max_rate=0;
113static int video_rc_min_rate=0;
114static float video_rc_initial_cplx=0;
115static float video_b_qfactor = 1.25;
116static float video_b_qoffset = 1.25;
b3a391e8 117static float video_i_qfactor = -0.8;
3aa102be 118static float video_i_qoffset = 0.0;
3bea5386 119static int me_method = ME_EPZS;
85f07f22
FB
120static int video_disable = 0;
121static int video_codec_id = CODEC_ID_NONE;
122static int same_quality = 0;
bc6caae2 123static int b_frames = 0;
e4986da9 124static int use_hq = 0;
29da453b 125static int use_4mv = 0;
cfcf0ffd 126static int do_deinterlace = 0;
4d2858de
MN
127static int workaround_bugs = FF_BUG_AUTODETECT;
128static int error_resilience = 2;
129static int error_concealment = 3;
463678ac 130static int dct_algo = 0;
2ad1516a 131static int idct_algo = 0;
1dbb6d90
MN
132static int use_part = 0;
133static int packet_size = 0;
f560dd82 134static int strict = 0;
59b571c1 135static int debug = 0;
85f07f22
FB
136
137static int gop_size = 12;
138static int intra_only = 0;
139static int audio_sample_rate = 44100;
140static int audio_bit_rate = 64000;
141static int audio_disable = 0;
142static int audio_channels = 1;
143static int audio_codec_id = CODEC_ID_NONE;
144
145static INT64 recording_time = 0;
146static int file_overwrite = 0;
147static char *str_title = NULL;
148static char *str_author = NULL;
149static char *str_copyright = NULL;
150static char *str_comment = NULL;
5727b222 151static int do_benchmark = 0;
a0663ba4 152static int do_hex_dump = 0;
a38469e1 153static int do_play = 0;
43f1708f 154static int do_psnr = 0;
ce7c56c2 155static int do_vstats = 0;
5abdb4b1
FB
156static int do_pass = 0;
157static char *pass_logfilename = NULL;
1629626f
FB
158static int audio_stream_copy = 0;
159static int video_stream_copy = 0;
5abdb4b1 160
8aa3ee32 161static char *video_grab_format = "video4linux";
79a7c268 162static char *video_device = NULL;
a5df11ab 163static int video_channel = 0;
79a7c268 164
8aa3ee32 165static char *audio_grab_format = "audio_device";
79a7c268 166static char *audio_device = NULL;
8aa3ee32 167
5abdb4b1 168#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
85f07f22
FB
169
170typedef struct AVOutputStream {
171 int file_index; /* file index */
172 int index; /* stream index in the output file */
173 int source_index; /* AVInputStream index */
174 AVStream *st; /* stream in the output file */
ec5517d5
FB
175 int encoding_needed; /* true if encoding needed for this stream */
176 int frame_number;
177 /* input pts and corresponding output pts
178 for A/V sync */
179 double sync_ipts;
c11ef252 180 double sync_ipts_offset;
ec5517d5 181 INT64 sync_opts;
85f07f22 182 /* video only */
34b10a57
D
183 int video_resample; /* video_resample and video_crop are mutually exclusive */
184 AVPicture pict_tmp; /* temporary image for resampling */
85f07f22 185 ImgReSampleContext *img_resample_ctx; /* for image resampling */
34b10a57
D
186
187 int video_crop; /* video_resample and video_crop are mutually exclusive */
188 int topBand; /* cropping area sizes */
189 int leftBand;
85f07f22
FB
190
191 /* audio only */
192 int audio_resample;
193 ReSampleContext *resample; /* for audio resampling */
194 FifoBuffer fifo; /* for compression: one audio fifo per codec */
5abdb4b1 195 FILE *logfile;
85f07f22
FB
196} AVOutputStream;
197
198typedef struct AVInputStream {
199 int file_index;
200 int index;
201 AVStream *st;
202 int discard; /* true if stream data should be discarded */
203 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
85f07f22 204 INT64 sample_index; /* current sample */
ec5517d5 205 int frame_decoded; /* true if a video or audio frame has been decoded */
85f07f22
FB
206} AVInputStream;
207
208typedef struct AVInputFile {
209 int eof_reached; /* true if eof reached */
210 int ist_index; /* index of first stream in ist_table */
211 int buffer_size; /* current total buffer size */
212 int buffer_size_max; /* buffer size at which we consider we can stop
213 buffering */
79fdaa4c 214 int nb_streams; /* nb streams we are aware of */
85f07f22
FB
215} AVInputFile;
216
bdc4796f
FB
217#ifndef CONFIG_WIN32
218
85f07f22
FB
219/* init terminal so that we can grab keys */
220static struct termios oldtty;
221
222static void term_exit(void)
223{
224 tcsetattr (0, TCSANOW, &oldtty);
225}
226
227static void term_init(void)
228{
229 struct termios tty;
230
231 tcgetattr (0, &tty);
232 oldtty = tty;
233
234 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
235 |INLCR|IGNCR|ICRNL|IXON);
236 tty.c_oflag |= OPOST;
237 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
238 tty.c_cflag &= ~(CSIZE|PARENB);
239 tty.c_cflag |= CS8;
240 tty.c_cc[VMIN] = 1;
241 tty.c_cc[VTIME] = 0;
242
243 tcsetattr (0, TCSANOW, &tty);
244
245 atexit(term_exit);
9ddd71fc
FR
246#ifdef CONFIG_BEOS_NETSERVER
247 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
248#endif
85f07f22
FB
249}
250
251/* read a key without blocking */
252static int read_key(void)
253{
9ddd71fc 254 int n = 1;
85f07f22 255 unsigned char ch;
9ddd71fc
FR
256#ifndef CONFIG_BEOS_NETSERVER
257 struct timeval tv;
85f07f22
FB
258 fd_set rfds;
259
260 FD_ZERO(&rfds);
261 FD_SET(0, &rfds);
262 tv.tv_sec = 0;
263 tv.tv_usec = 0;
264 n = select(1, &rfds, NULL, NULL, &tv);
9ddd71fc 265#endif
85f07f22 266 if (n > 0) {
cb09b2ed
PG
267 n = read(0, &ch, 1);
268 if (n == 1)
85f07f22 269 return ch;
cb09b2ed
PG
270
271 return n;
85f07f22
FB
272 }
273 return -1;
274}
275
a38469e1 276#else
85f07f22 277
a38469e1
FB
278/* no interactive support */
279static void term_exit(void)
85f07f22 280{
a38469e1 281}
85f07f22 282
a38469e1
FB
283static void term_init(void)
284{
285}
85f07f22 286
a38469e1
FB
287static int read_key(void)
288{
cb09b2ed 289 return 0;
85f07f22
FB
290}
291
a38469e1 292#endif
bdc4796f 293
85f07f22
FB
294int read_ffserver_streams(AVFormatContext *s, const char *filename)
295{
79fdaa4c 296 int i, err;
85f07f22
FB
297 AVFormatContext *ic;
298
79fdaa4c
FB
299 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
300 if (err < 0)
301 return err;
85f07f22
FB
302 /* copy stream format */
303 s->nb_streams = ic->nb_streams;
304 for(i=0;i<ic->nb_streams;i++) {
305 AVStream *st;
1e491e29 306
85f07f22
FB
307 st = av_mallocz(sizeof(AVFormatContext));
308 memcpy(st, ic->streams[i], sizeof(AVStream));
309 s->streams[i] = st;
310 }
311
312 av_close_input_file(ic);
313 return 0;
314}
315
817b23ff 316#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
85f07f22
FB
317
318static void do_audio_out(AVFormatContext *s,
319 AVOutputStream *ost,
320 AVInputStream *ist,
321 unsigned char *buf, int size)
322{
323 UINT8 *buftmp;
324 UINT8 audio_buf[2*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
ff29712a 325 UINT8 audio_out[4*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it - yep really WMA */
85f07f22
FB
326 int size_out, frame_bytes, ret;
327 AVCodecContext *enc;
328
329 enc = &ost->st->codec;
330
331 if (ost->audio_resample) {
332 buftmp = audio_buf;
333 size_out = audio_resample(ost->resample,
334 (short *)buftmp, (short *)buf,
335 size / (ist->st->codec.channels * 2));
336 size_out = size_out * enc->channels * 2;
337 } else {
338 buftmp = buf;
339 size_out = size;
340 }
341
342 /* now encode as many frames as possible */
a0663ba4 343 if (enc->frame_size > 1) {
85f07f22
FB
344 /* output resampled raw samples */
345 fifo_write(&ost->fifo, buftmp, size_out,
346 &ost->fifo.wptr);
347
348 frame_bytes = enc->frame_size * 2 * enc->channels;
349
350 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
351 &ost->fifo.rptr) == 0) {
a0663ba4
FB
352 ret = avcodec_encode_audio(enc, audio_out, sizeof(audio_out),
353 (short *)audio_buf);
ec5517d5 354 av_write_frame(s, ost->index, audio_out, ret);
85f07f22
FB
355 }
356 } else {
a0663ba4
FB
357 /* output a pcm frame */
358 /* XXX: change encoding codec API to avoid this ? */
359 switch(enc->codec->id) {
360 case CODEC_ID_PCM_S16LE:
361 case CODEC_ID_PCM_S16BE:
362 case CODEC_ID_PCM_U16LE:
363 case CODEC_ID_PCM_U16BE:
364 break;
365 default:
366 size_out = size_out >> 1;
367 break;
368 }
369 ret = avcodec_encode_audio(enc, audio_out, size_out,
ff29712a 370 (short *)buftmp);
ec5517d5 371 av_write_frame(s, ost->index, audio_out, ret);
85f07f22
FB
372 }
373}
374
375/* write a picture to a raw mux */
cfcf0ffd
FB
376static void write_picture(AVFormatContext *s, int index, AVPicture *picture,
377 int pix_fmt, int w, int h)
85f07f22
FB
378{
379 UINT8 *buf, *src, *dest;
380 int size, j, i;
cfcf0ffd 381
85f07f22
FB
382 /* XXX: not efficient, should add test if we can take
383 directly the AVPicture */
cfcf0ffd
FB
384 switch(pix_fmt) {
385 case PIX_FMT_YUV420P:
5b0ad91b 386 size = avpicture_get_size(pix_fmt, w, h);
0f1578af 387 buf = av_malloc(size);
5b0ad91b
J
388 if (!buf)
389 return;
cfcf0ffd
FB
390 dest = buf;
391 for(i=0;i<3;i++) {
392 if (i == 1) {
393 w >>= 1;
394 h >>= 1;
395 }
396 src = picture->data[i];
397 for(j=0;j<h;j++) {
398 memcpy(dest, src, w);
399 dest += w;
400 src += picture->linesize[i];
401 }
402 }
403 break;
404 case PIX_FMT_YUV422P:
405 size = (w * h) * 2;
0f1578af 406 buf = av_malloc(size);
5b0ad91b
J
407 if (!buf)
408 return;
cfcf0ffd
FB
409 dest = buf;
410 for(i=0;i<3;i++) {
411 if (i == 1) {
412 w >>= 1;
413 }
414 src = picture->data[i];
415 for(j=0;j<h;j++) {
416 memcpy(dest, src, w);
417 dest += w;
418 src += picture->linesize[i];
419 }
420 }
421 break;
422 case PIX_FMT_YUV444P:
423 size = (w * h) * 3;
0f1578af 424 buf = av_malloc(size);
5b0ad91b
J
425 if (!buf)
426 return;
cfcf0ffd
FB
427 dest = buf;
428 for(i=0;i<3;i++) {
429 src = picture->data[i];
430 for(j=0;j<h;j++) {
431 memcpy(dest, src, w);
432 dest += w;
433 src += picture->linesize[i];
434 }
435 }
436 break;
437 case PIX_FMT_YUV422:
438 size = (w * h) * 2;
0f1578af 439 buf = av_malloc(size);
5b0ad91b
J
440 if (!buf)
441 return;
cfcf0ffd
FB
442 dest = buf;
443 src = picture->data[0];
444 for(j=0;j<h;j++) {
445 memcpy(dest, src, w * 2);
446 dest += w * 2;
447 src += picture->linesize[0];
85f07f22 448 }
cfcf0ffd
FB
449 break;
450 case PIX_FMT_RGB24:
451 case PIX_FMT_BGR24:
452 size = (w * h) * 3;
0f1578af 453 buf = av_malloc(size);
5b0ad91b
J
454 if (!buf)
455 return;
cfcf0ffd
FB
456 dest = buf;
457 src = picture->data[0];
85f07f22 458 for(j=0;j<h;j++) {
cfcf0ffd
FB
459 memcpy(dest, src, w * 3);
460 dest += w * 3;
461 src += picture->linesize[0];
85f07f22 462 }
cfcf0ffd
FB
463 break;
464 default:
465 return;
85f07f22 466 }
ec5517d5 467 av_write_frame(s, index, buf, size);
0f1578af 468 av_free(buf);
85f07f22
FB
469}
470
10d104e4
PG
471static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
472{
473 AVCodecContext *dec;
474 AVPicture *picture2;
475 AVPicture picture_tmp;
476 UINT8 *buf = 0;
477
478 dec = &ist->st->codec;
479
480 /* deinterlace : must be done before any resize */
481 if (do_deinterlace) {
482 int size;
483
484 /* create temporary picture */
485 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
486 buf = av_malloc(size);
487 if (!buf)
488 return;
489
490 picture2 = &picture_tmp;
491 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
492
493 if (avpicture_deinterlace(picture2, picture,
494 dec->pix_fmt, dec->width, dec->height) < 0) {
495 /* if error, do not deinterlace */
496 av_free(buf);
497 buf = NULL;
498 picture2 = picture;
499 }
500 } else {
501 picture2 = picture;
502 }
503
504 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
505
506 if (picture != picture2)
507 *picture = *picture2;
508 *bufp = buf;
509}
510
ec5517d5
FB
511/* we begin to correct av delay at this threshold */
512#define AV_DELAY_MAX 0.100
85f07f22
FB
513
514static void do_video_out(AVFormatContext *s,
515 AVOutputStream *ost,
516 AVInputStream *ist,
34b10a57 517 AVPicture *in_picture,
ec5517d5 518 int *frame_size, AVOutputStream *audio_sync)
85f07f22 519{
ec5517d5 520 int nb_frames, i, ret;
34b10a57
D
521 AVPicture *final_picture, *formatted_picture;
522 AVPicture picture_format_temp, picture_crop_temp;
cb09b2ed 523 static UINT8 *video_buffer;
cfcf0ffd
FB
524 UINT8 *buf = NULL, *buf1 = NULL;
525 AVCodecContext *enc, *dec;
85f07f22 526
33a1f1a3 527#define VIDEO_BUFFER_SIZE (1024*1024)
33a1f1a3 528
85f07f22 529 enc = &ost->st->codec;
cfcf0ffd 530 dec = &ist->st->codec;
85f07f22 531
ec5517d5
FB
532 /* by default, we output a single frame */
533 nb_frames = 1;
534
204c0f48
PG
535 *frame_size = 0;
536
ec5517d5
FB
537 /* NOTE: the A/V sync is always done by considering the audio is
538 the master clock. It is suffisant for transcoding or playing,
539 but not for the general case */
540 if (audio_sync) {
541 /* compute the A-V delay and duplicate/remove frames if needed */
542 double adelta, vdelta, apts, vpts, av_delay;
543
544 if (audio_sync->sync_ipts != AV_NOPTS_VALUE &&
545 ost->sync_ipts != AV_NOPTS_VALUE) {
546
547 adelta = (double)(ost->st->pts.val - audio_sync->sync_opts) *
548 s->pts_num / s->pts_den;
549 apts = audio_sync->sync_ipts + adelta;
550
551 vdelta = (double)(ost->st->pts.val - ost->sync_opts) *
552 s->pts_num / s->pts_den;
553 vpts = ost->sync_ipts + vdelta;
554
555 av_delay = apts - vpts;
556 // printf("delay=%f\n", av_delay);
557 if (av_delay < -AV_DELAY_MAX)
558 nb_frames = 2;
559 else if (av_delay > AV_DELAY_MAX)
560 nb_frames = 0;
561 }
10d104e4
PG
562 } else {
563 double vdelta;
564
565 if (ost->sync_ipts != AV_NOPTS_VALUE) {
c11ef252 566 vdelta = (double)(ost->st->pts.val) * s->pts_num / s->pts_den - (ost->sync_ipts - ost->sync_ipts_offset);
be4ce157 567 if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
c11ef252
PG
568 if (vdelta < -AV_DELAY_MAX)
569 nb_frames = 2;
570 else if (vdelta > AV_DELAY_MAX)
571 nb_frames = 0;
572 } else {
573 ost->sync_ipts_offset -= vdelta;
be4ce157
PG
574 if (!ost->sync_ipts_offset)
575 ost->sync_ipts_offset = 0.000001; /* one microsecond */
c11ef252
PG
576 }
577
be4ce157 578#if defined(PJSG)
c11ef252
PG
579 {
580 static char *action[] = { "drop frame", "copy frame", "dup frame" };
581 printf("Input PTS %12.6f, output PTS %12.6f: %s\n",
582 (double) ost->sync_ipts, (double) ost->st->pts.val * s->pts_num / s->pts_den,
583 action[nb_frames]);
584 }
585#endif
10d104e4 586 }
ec5517d5 587 }
ec5517d5 588 if (nb_frames <= 0)
85f07f22 589 return;
ce7c56c2 590
cb09b2ed 591 if (!video_buffer)
ec5517d5
FB
592 video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
593 if (!video_buffer)
594 return;
c04643a2 595
cfcf0ffd
FB
596 /* convert pixel format if needed */
597 if (enc->pix_fmt != dec->pix_fmt) {
598 int size;
599
600 /* create temporary picture */
601 size = avpicture_get_size(enc->pix_fmt, dec->width, dec->height);
0f1578af 602 buf = av_malloc(size);
cfcf0ffd
FB
603 if (!buf)
604 return;
34b10a57
D
605 formatted_picture = &picture_format_temp;
606 avpicture_fill(formatted_picture, buf, enc->pix_fmt, dec->width, dec->height);
cfcf0ffd 607
34b10a57
D
608 if (img_convert(formatted_picture, enc->pix_fmt,
609 in_picture, dec->pix_fmt,
cfcf0ffd
FB
610 dec->width, dec->height) < 0) {
611 fprintf(stderr, "pixel format conversion not handled\n");
612 goto the_end;
613 }
614 } else {
34b10a57 615 formatted_picture = in_picture;
cfcf0ffd
FB
616 }
617
618 /* XXX: resampling could be done before raw format convertion in
619 some cases to go faster */
620 /* XXX: only works for YUV420P */
85f07f22 621 if (ost->video_resample) {
34b10a57
D
622 final_picture = &ost->pict_tmp;
623 img_resample(ost->img_resample_ctx, final_picture, formatted_picture);
624 } else if (ost->video_crop) {
625 picture_crop_temp.data[0] = formatted_picture->data[0] +
626 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
627
628 picture_crop_temp.data[1] = formatted_picture->data[1] +
629 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
630 (ost->leftBand >> 1);
631
632 picture_crop_temp.data[2] = formatted_picture->data[2] +
633 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
634 (ost->leftBand >> 1);
635
636 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
637 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
638 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
639 final_picture = &picture_crop_temp;
85f07f22 640 } else {
34b10a57 641 final_picture = formatted_picture;
85f07f22 642 }
85f07f22
FB
643 /* duplicates frame if needed */
644 /* XXX: pb because no interleaving */
ec5517d5 645 for(i=0;i<nb_frames;i++) {
85f07f22 646 if (enc->codec_id != CODEC_ID_RAWVIDEO) {
492cd3a9 647 AVFrame big_picture;
1e491e29 648
492cd3a9 649 memset(&big_picture, 0, sizeof(AVFrame));
34b10a57 650 *(AVPicture*)&big_picture= *final_picture;
1e491e29 651
85f07f22
FB
652 /* handles sameq here. This is not correct because it may
653 not be a global option */
654 if (same_quality) {
1e491e29
MN
655 big_picture.quality = ist->st->quality;
656 }else
657 big_picture.quality = ost->st->quality;
6dc96cb0 658
cfcf0ffd 659 ret = avcodec_encode_video(enc,
33a1f1a3 660 video_buffer, VIDEO_BUFFER_SIZE,
1e491e29 661 &big_picture);
44429457 662 //enc->frame_number = enc->real_pict_num;
ec5517d5 663 av_write_frame(s, ost->index, video_buffer, ret);
ce7c56c2 664 *frame_size = ret;
a5dc85ef 665 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
44429457 666 // enc->frame_number-1, enc->real_pict_num, ret,
a5dc85ef 667 // enc->pict_type);
5abdb4b1
FB
668 /* if two pass, output log */
669 if (ost->logfile && enc->stats_out) {
670 fprintf(ost->logfile, "%s", enc->stats_out);
671 }
85f07f22 672 } else {
7002684e
FB
673 if (s->oformat->flags & AVFMT_RAWPICTURE) {
674 /* raw pictures are written as AVPicture structure to
675 avoid any copies. We support temorarily the older
676 method. */
ec5517d5 677 av_write_frame(s, ost->index,
34b10a57 678 (UINT8 *)final_picture, sizeof(AVPicture));
7002684e 679 } else {
34b10a57 680 write_picture(s, ost->index, final_picture, enc->pix_fmt,
ec5517d5 681 enc->width, enc->height);
7002684e 682 }
85f07f22 683 }
ec5517d5 684 ost->frame_number++;
85f07f22 685 }
ec5517d5 686 the_end:
0f1578af
FB
687 av_free(buf);
688 av_free(buf1);
85f07f22
FB
689}
690
140cb663
MN
691static double psnr(double d){
692 if(d==0) return INFINITY;
693 return -10.0*log(d)/log(10);
694}
695
ec5517d5
FB
696static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
697 int frame_size)
ce7c56c2
J
698{
699 static FILE *fvstats=NULL;
700 static INT64 total_size = 0;
ce7c56c2 701 char filename[40];
bf5af568
FB
702 time_t today2;
703 struct tm *today;
ce7c56c2
J
704 AVCodecContext *enc;
705 int frame_number;
706 INT64 ti;
707 double ti1, bitrate, avg_bitrate;
708
709 if (!fvstats) {
710 today2 = time(NULL);
711 today = localtime(&today2);
712 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
713 today->tm_min,
714 today->tm_sec);
715 fvstats = fopen(filename,"w");
716 if (!fvstats) {
717 perror("fopen");
718 exit(1);
719 }
720 }
721
722 ti = MAXINT64;
723 enc = &ost->st->codec;
724 total_size += frame_size;
725 if (enc->codec_type == CODEC_TYPE_VIDEO) {
ec5517d5 726 frame_number = ost->frame_number;
492cd3a9 727 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality);
140cb663 728 if (enc->flags&CODEC_FLAG_PSNR)
492cd3a9 729 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
ce7c56c2
J
730
731 fprintf(fvstats,"f_size= %6d ", frame_size);
ec5517d5
FB
732 /* compute pts value */
733 ti1 = (double)ost->st->pts.val * os->pts_num / os->pts_den;
ce7c56c2
J
734 if (ti1 < 0.01)
735 ti1 = 0.01;
736
737 bitrate = (double)(frame_size * 8) * enc->frame_rate / FRAME_RATE_BASE / 1000.0;
738 avg_bitrate = (double)(total_size * 8) / ti1 / 1000.0;
739 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
740 (double)total_size / 1024, ti1, bitrate, avg_bitrate);
492cd3a9 741 fprintf(fvstats,"type= %s\n", enc->coded_frame->key_frame == 1 ? "I" : "P");
ce7c56c2 742 }
ec5517d5
FB
743}
744
745void print_report(AVFormatContext **output_files,
746 AVOutputStream **ost_table, int nb_ostreams,
747 int is_last_report)
748{
749 char buf[1024];
750 AVOutputStream *ost;
751 AVFormatContext *oc, *os;
752 INT64 total_size;
753 AVCodecContext *enc;
754 int frame_number, vid, i;
755 double bitrate, ti1, pts;
756 static INT64 last_time = -1;
757
758 if (!is_last_report) {
759 INT64 cur_time;
760 /* display the report every 0.5 seconds */
761 cur_time = av_gettime();
762 if (last_time == -1) {
763 last_time = cur_time;
764 return;
765 }
766 if ((cur_time - last_time) < 500000)
767 return;
768 last_time = cur_time;
769 }
770
ce7c56c2 771
ec5517d5
FB
772 oc = output_files[0];
773
774 total_size = url_ftell(&oc->pb);
775
776 buf[0] = '\0';
777 ti1 = 1e10;
778 vid = 0;
779 for(i=0;i<nb_ostreams;i++) {
780 ost = ost_table[i];
781 os = output_files[ost->file_index];
782 enc = &ost->st->codec;
10d104e4 783 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1e491e29 784 sprintf(buf + strlen(buf), "q=%2.1f ",
492cd3a9 785 enc->coded_frame->quality);
10d104e4 786 }
ec5517d5
FB
787 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
788 frame_number = ost->frame_number;
1e491e29 789 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
492cd3a9 790 frame_number, enc->coded_frame ? enc->coded_frame->quality : 0);
140cb663 791 if (enc->flags&CODEC_FLAG_PSNR)
492cd3a9 792 sprintf(buf + strlen(buf), "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
ec5517d5
FB
793 vid = 1;
794 }
795 /* compute min output value */
796 pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
5d9827bc 797 if ((pts < ti1) && (pts > 0))
ec5517d5
FB
798 ti1 = pts;
799 }
800 if (ti1 < 0.01)
801 ti1 = 0.01;
802 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
803
804 sprintf(buf + strlen(buf),
805 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
806 (double)total_size / 1024, ti1, bitrate);
ce7c56c2 807
ec5517d5 808 fprintf(stderr, "%s ", buf);
ce7c56c2 809
ec5517d5
FB
810 if (is_last_report) {
811 fprintf(stderr, "\n");
812 } else {
813 fprintf(stderr, "\r");
814 fflush(stderr);
815 }
ce7c56c2
J
816}
817
85f07f22
FB
818/*
819 * The following code is the main loop of the file converter
820 */
821static int av_encode(AVFormatContext **output_files,
822 int nb_output_files,
823 AVFormatContext **input_files,
824 int nb_input_files,
825 AVStreamMap *stream_maps, int nb_stream_maps)
826{
ec5517d5 827 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, pts_set;
85f07f22
FB
828 AVFormatContext *is, *os;
829 AVCodecContext *codec, *icodec;
830 AVOutputStream *ost, **ost_table = NULL;
831 AVInputStream *ist, **ist_table = NULL;
bdc4796f 832 AVInputFile *file_table;
51bd4565 833 AVFormatContext *stream_no_data;
cb09b2ed 834 int key;
bdc4796f 835
51bd4565 836 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
bdc4796f
FB
837 if (!file_table)
838 goto fail;
85f07f22 839
85f07f22
FB
840 /* input stream init */
841 j = 0;
842 for(i=0;i<nb_input_files;i++) {
843 is = input_files[i];
844 file_table[i].ist_index = j;
79fdaa4c 845 file_table[i].nb_streams = is->nb_streams;
85f07f22
FB
846 j += is->nb_streams;
847 }
848 nb_istreams = j;
849
850 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
851 if (!ist_table)
bdc4796f 852 goto fail;
85f07f22
FB
853
854 for(i=0;i<nb_istreams;i++) {
855 ist = av_mallocz(sizeof(AVInputStream));
856 if (!ist)
857 goto fail;
858 ist_table[i] = ist;
859 }
860 j = 0;
861 for(i=0;i<nb_input_files;i++) {
862 is = input_files[i];
863 for(k=0;k<is->nb_streams;k++) {
864 ist = ist_table[j++];
865 ist->st = is->streams[k];
866 ist->file_index = i;
867 ist->index = k;
868 ist->discard = 1; /* the stream is discarded by default
869 (changed later) */
870 }
871 }
872
873 /* output stream init */
874 nb_ostreams = 0;
875 for(i=0;i<nb_output_files;i++) {
876 os = output_files[i];
877 nb_ostreams += os->nb_streams;
878 }
879 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
880 fprintf(stderr, "Number of stream maps must match number of output streams\n");
881 exit(1);
882 }
883
884 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
885 if (!ost_table)
886 goto fail;
887 for(i=0;i<nb_ostreams;i++) {
888 ost = av_mallocz(sizeof(AVOutputStream));
889 if (!ost)
890 goto fail;
891 ost_table[i] = ost;
892 }
893
894 n = 0;
895 for(k=0;k<nb_output_files;k++) {
896 os = output_files[k];
897 for(i=0;i<os->nb_streams;i++) {
898 int found;
899 ost = ost_table[n++];
900 ost->file_index = k;
901 ost->index = i;
902 ost->st = os->streams[i];
903 if (nb_stream_maps > 0) {
904 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
905 stream_maps[n-1].stream_index;
906 } else {
907 /* get corresponding input stream index : we select the first one with the right type */
908 found = 0;
909 for(j=0;j<nb_istreams;j++) {
910 ist = ist_table[j];
911 if (ist->discard &&
912 ist->st->codec.codec_type == ost->st->codec.codec_type) {
913 ost->source_index = j;
914 found = 1;
915 }
916 }
917
918 if (!found) {
919 /* try again and reuse existing stream */
920 for(j=0;j<nb_istreams;j++) {
921 ist = ist_table[j];
922 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
923 ost->source_index = j;
924 found = 1;
925 }
926 }
927 if (!found) {
928 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
929 ost->file_index, ost->index);
930 exit(1);
931 }
932 }
933 }
934 ist = ist_table[ost->source_index];
935 ist->discard = 0;
936 }
937 }
938
85f07f22
FB
939 /* for each output stream, we compute the right encoding parameters */
940 for(i=0;i<nb_ostreams;i++) {
941 ost = ost_table[i];
942 ist = ist_table[ost->source_index];
943
944 codec = &ost->st->codec;
945 icodec = &ist->st->codec;
946
1629626f
FB
947 if (ost->st->stream_copy) {
948 /* if stream_copy is selected, no need to decode or encode */
949 codec->codec_id = icodec->codec_id;
950 codec->codec_type = icodec->codec_type;
951 codec->codec_tag = icodec->codec_tag;
952 codec->bit_rate = icodec->bit_rate;
953 switch(codec->codec_type) {
954 case CODEC_TYPE_AUDIO:
955 codec->sample_rate = icodec->sample_rate;
956 codec->channels = icodec->channels;
957 break;
958 case CODEC_TYPE_VIDEO:
959 codec->frame_rate = icodec->frame_rate;
960 codec->width = icodec->width;
961 codec->height = icodec->height;
962 break;
963 default:
964 av_abort();
965 }
966 } else {
967 switch(codec->codec_type) {
968 case CODEC_TYPE_AUDIO:
85f07f22
FB
969 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
970 goto fail;
1629626f 971
85f07f22
FB
972 if (codec->channels == icodec->channels &&
973 codec->sample_rate == icodec->sample_rate) {
974 ost->audio_resample = 0;
975 } else {
e0d2714a
J
976 if (codec->channels != icodec->channels &&
977 icodec->codec_id == CODEC_ID_AC3) {
978 /* Special case for 5:1 AC3 input */
979 /* and mono or stereo output */
6dc96cb0
J
980 /* Request specific number of channels */
981 icodec->channels = codec->channels;
982 if (codec->sample_rate == icodec->sample_rate)
983 ost->audio_resample = 0;
984 else {
985 ost->audio_resample = 1;
986 ost->resample = audio_resample_init(codec->channels, icodec->channels,
987 codec->sample_rate,
988 icodec->sample_rate);
989 }
e0d2714a
J
990 /* Request specific number of channels */
991 icodec->channels = codec->channels;
992 } else {
993 ost->audio_resample = 1;
994 ost->resample = audio_resample_init(codec->channels, icodec->channels,
85f07f22
FB
995 codec->sample_rate,
996 icodec->sample_rate);
e0d2714a 997 }
85f07f22
FB
998 }
999 ist->decoding_needed = 1;
1000 ost->encoding_needed = 1;
1629626f
FB
1001 break;
1002 case CODEC_TYPE_VIDEO:
85f07f22 1003 if (codec->width == icodec->width &&
34b10a57
D
1004 codec->height == icodec->height &&
1005 frame_topBand == 0 &&
1006 frame_bottomBand == 0 &&
1007 frame_leftBand == 0 &&
1008 frame_rightBand == 0)
1009 {
1010 ost->video_resample = 0;
1011 ost->video_crop = 0;
1012 } else if ((codec->width == icodec->width -
1013 (frame_leftBand + frame_rightBand)) &&
1014 (codec->height == icodec->height -
1015 (frame_topBand + frame_bottomBand)))
1016 {
85f07f22 1017 ost->video_resample = 0;
34b10a57
D
1018 ost->video_crop = 1;
1019 ost->topBand = frame_topBand;
1020 ost->leftBand = frame_leftBand;
85f07f22
FB
1021 } else {
1022 UINT8 *buf;
1023 ost->video_resample = 1;
34b10a57 1024 ost->video_crop = 0; // cropping is handled as part of resample
0f1578af 1025 buf = av_malloc((codec->width * codec->height * 3) / 2);
85f07f22
FB
1026 if (!buf)
1027 goto fail;
1028 ost->pict_tmp.data[0] = buf;
1029 ost->pict_tmp.data[1] = ost->pict_tmp.data[0] + (codec->width * codec->height);
1030 ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (codec->width * codec->height) / 4;
1031 ost->pict_tmp.linesize[0] = codec->width;
1032 ost->pict_tmp.linesize[1] = codec->width / 2;
1033 ost->pict_tmp.linesize[2] = codec->width / 2;
1034
ab6d194a 1035 ost->img_resample_ctx = img_resample_full_init(
85f07f22 1036 ost->st->codec.width, ost->st->codec.height,
ab6d194a
MN
1037 ist->st->codec.width, ist->st->codec.height,
1038 frame_topBand, frame_bottomBand,
1039 frame_leftBand, frame_rightBand);
85f07f22
FB
1040 }
1041 ost->encoding_needed = 1;
1042 ist->decoding_needed = 1;
1629626f
FB
1043 break;
1044 default:
1045 av_abort();
85f07f22 1046 }
1629626f
FB
1047 /* two pass mode */
1048 if (ost->encoding_needed &&
1049 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1050 char logfilename[1024];
1051 FILE *f;
1052 int size;
1053 char *logbuffer;
1054
1055 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1056 pass_logfilename ?
1057 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1058 if (codec->flags & CODEC_FLAG_PASS1) {
1059 f = fopen(logfilename, "w");
1060 if (!f) {
1061 perror(logfilename);
1062 exit(1);
1063 }
1064 ost->logfile = f;
1065 } else {
1066 /* read the log file */
1067 f = fopen(logfilename, "r");
1068 if (!f) {
1069 perror(logfilename);
1070 exit(1);
1071 }
1072 fseek(f, 0, SEEK_END);
1073 size = ftell(f);
1074 fseek(f, 0, SEEK_SET);
1075 logbuffer = av_malloc(size + 1);
1076 if (!logbuffer) {
1077 fprintf(stderr, "Could not allocate log buffer\n");
1078 exit(1);
1079 }
1080 fread(logbuffer, 1, size, f);
1081 fclose(f);
1082 logbuffer[size] = '\0';
1083 codec->stats_in = logbuffer;
5abdb4b1 1084 }
5abdb4b1
FB
1085 }
1086 }
85f07f22
FB
1087 }
1088
1629626f
FB
1089 /* dump the file output parameters - cannot be done before in case
1090 of stream copy */
1091 for(i=0;i<nb_output_files;i++) {
1092 dump_format(output_files[i], i, output_files[i]->filename, 1);
1093 }
1094
1095 /* dump the stream mapping */
1096 fprintf(stderr, "Stream mapping:\n");
1097 for(i=0;i<nb_ostreams;i++) {
1098 ost = ost_table[i];
1099 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1100 ist_table[ost->source_index]->file_index,
1101 ist_table[ost->source_index]->index,
1102 ost->file_index,
1103 ost->index);
1104 }
1105
85f07f22
FB
1106 /* open each encoder */
1107 for(i=0;i<nb_ostreams;i++) {
1108 ost = ost_table[i];
1109 if (ost->encoding_needed) {
1110 AVCodec *codec;
1111 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1112 if (!codec) {
1113 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1114 ost->file_index, ost->index);
1115 exit(1);
1116 }
1117 if (avcodec_open(&ost->st->codec, codec) < 0) {
1118 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1119 ost->file_index, ost->index);
1120 exit(1);
1121 }
1122 }
1123 }
1124
1125 /* open each decoder */
1126 for(i=0;i<nb_istreams;i++) {
1127 ist = ist_table[i];
1128 if (ist->decoding_needed) {
1129 AVCodec *codec;
1130 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1131 if (!codec) {
10d104e4
PG
1132 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1133 ist->st->codec.codec_id, ist->file_index, ist->index);
85f07f22
FB
1134 exit(1);
1135 }
1136 if (avcodec_open(&ist->st->codec, codec) < 0) {
1137 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1138 ist->file_index, ist->index);
1139 exit(1);
1140 }
6dc96cb0
J
1141 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1142 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
ec5517d5 1143 ist->frame_decoded = 1;
85f07f22
FB
1144 }
1145 }
1146
1147 /* init pts */
1148 for(i=0;i<nb_istreams;i++) {
1149 ist = ist_table[i];
85f07f22
FB
1150 }
1151
1152 /* compute buffer size max (should use a complete heuristic) */
1153 for(i=0;i<nb_input_files;i++) {
1154 file_table[i].buffer_size_max = 2048;
1155 }
1156
1157 /* open files and write file headers */
1158 for(i=0;i<nb_output_files;i++) {
1159 os = output_files[i];
79fdaa4c 1160 if (av_write_header(os) < 0) {
a38469e1
FB
1161 fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
1162 ret = -EINVAL;
1163 goto fail;
1164 }
85f07f22
FB
1165 }
1166
a38469e1
FB
1167#ifndef CONFIG_WIN32
1168 if (!do_play) {
1169 fprintf(stderr, "Press [q] to stop encoding\n");
1170 } else {
1171 fprintf(stderr, "Press [q] to stop playing\n");
1172 }
1173#endif
1174 term_init();
1175
51bd4565 1176 stream_no_data = 0;
cb09b2ed 1177 key = -1;
51bd4565 1178
85f07f22
FB
1179 for(;;) {
1180 int file_index, ist_index;
1181 AVPacket pkt;
1182 UINT8 *ptr;
1183 int len;
1184 UINT8 *data_buf;
1185 int data_size, got_picture;
1186 AVPicture picture;
1187 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
10d104e4 1188 void *buffer_to_free;
ec5517d5
FB
1189 double pts_min;
1190
85f07f22 1191 redo:
a38469e1 1192 /* if 'q' pressed, exits */
cb09b2ed
PG
1193 if (key) {
1194 /* read_key() returns 0 on EOF */
1195 key = read_key();
1196 if (key == 'q')
1197 break;
1198 }
a38469e1 1199
ec5517d5
FB
1200 /* select the stream that we must read now by looking at the
1201 smallest output pts */
85f07f22 1202 file_index = -1;
ec5517d5
FB
1203 pts_min = 1e10;
1204 for(i=0;i<nb_ostreams;i++) {
1205 double pts;
1206 ost = ost_table[i];
1207 os = output_files[ost->file_index];
1208 ist = ist_table[ost->source_index];
1209 pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
1210 if (!file_table[ist->file_index].eof_reached &&
1211 pts < pts_min) {
1212 pts_min = pts;
85f07f22
FB
1213 file_index = ist->file_index;
1214 }
1215 }
1216 /* if none, if is finished */
51bd4565 1217 if (file_index < 0) {
85f07f22 1218 break;
ec5517d5
FB
1219 }
1220
85f07f22 1221 /* finish if recording time exhausted */
ec5517d5 1222 if (recording_time > 0 && pts_min >= (recording_time / 1000000.0))
85f07f22 1223 break;
ec5517d5 1224
85f07f22 1225 /* read a packet from it and output it in the fifo */
85f07f22
FB
1226 is = input_files[file_index];
1227 if (av_read_packet(is, &pkt) < 0) {
1228 file_table[file_index].eof_reached = 1;
1229 continue;
1230 }
51bd4565
PG
1231 if (!pkt.size) {
1232 stream_no_data = is;
1233 } else {
1234 stream_no_data = 0;
1235 }
817b23ff
FB
1236 if (do_hex_dump) {
1237 printf("stream #%d, size=%d:\n", pkt.stream_index, pkt.size);
1238 av_hex_dump(pkt.data, pkt.size);
1239 }
79fdaa4c
FB
1240 /* the following test is needed in case new streams appear
1241 dynamically in stream : we ignore them */
1242 if (pkt.stream_index >= file_table[file_index].nb_streams)
bf5af568 1243 goto discard_packet;
85f07f22
FB
1244 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1245 ist = ist_table[ist_index];
bf5af568
FB
1246 if (ist->discard)
1247 goto discard_packet;
85f07f22 1248
34b10a57 1249 // printf("read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
85f07f22
FB
1250
1251 len = pkt.size;
1252 ptr = pkt.data;
ec5517d5 1253 pts_set = 0;
85f07f22 1254 while (len > 0) {
ec5517d5
FB
1255 INT64 ipts;
1256
1257 ipts = AV_NOPTS_VALUE;
85f07f22
FB
1258
1259 /* decode the packet if needed */
1260 data_buf = NULL; /* fail safe */
1261 data_size = 0;
1262 if (ist->decoding_needed) {
ec5517d5
FB
1263 /* NOTE1: we only take into account the PTS if a new
1264 frame has begun (MPEG semantics) */
1265 /* NOTE2: even if the fraction is not initialized,
1266 av_frac_set can be used to set the integer part */
1267 if (ist->frame_decoded &&
1268 pkt.pts != AV_NOPTS_VALUE &&
1269 !pts_set) {
1270 ipts = pkt.pts;
1271 ist->frame_decoded = 0;
1272 pts_set = 1;
1273 }
1274
85f07f22
FB
1275 switch(ist->st->codec.codec_type) {
1276 case CODEC_TYPE_AUDIO:
a0663ba4
FB
1277 /* XXX: could avoid copy if PCM 16 bits with same
1278 endianness as CPU */
1279 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1280 ptr, len);
1281 if (ret < 0)
1282 goto fail_decode;
afc80f59
J
1283 /* Some bug in mpeg audio decoder gives */
1284 /* data_size < 0, it seems they are overflows */
1285 if (data_size <= 0) {
a0663ba4
FB
1286 /* no audio frame */
1287 ptr += ret;
1288 len -= ret;
1289 continue;
85f07f22 1290 }
a0663ba4 1291 data_buf = (UINT8 *)samples;
85f07f22
FB
1292 break;
1293 case CODEC_TYPE_VIDEO:
1294 if (ist->st->codec.codec_id == CODEC_ID_RAWVIDEO) {
1295 int size;
8409b8fe 1296
85f07f22 1297 size = (ist->st->codec.width * ist->st->codec.height);
cfcf0ffd
FB
1298 avpicture_fill(&picture, ptr,
1299 ist->st->codec.pix_fmt,
1300 ist->st->codec.width,
1301 ist->st->codec.height);
85f07f22
FB
1302 ret = len;
1303 } else {
492cd3a9 1304 AVFrame big_picture;
1e491e29 1305
85f07f22
FB
1306 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1307 ret = avcodec_decode_video(&ist->st->codec,
1e491e29
MN
1308 &big_picture, &got_picture, ptr, len);
1309 picture= *(AVPicture*)&big_picture;
1310 ist->st->quality= big_picture.quality;
85f07f22
FB
1311 if (ret < 0) {
1312 fail_decode:
1313 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1314 ist->file_index, ist->index);
1315 av_free_packet(&pkt);
1316 goto redo;
1317 }
1318 if (!got_picture) {
1319 /* no picture yet */
1320 ptr += ret;
1321 len -= ret;
1322 continue;
1323 }
6dc96cb0 1324
85f07f22
FB
1325 }
1326 break;
1327 default:
1328 goto fail_decode;
1329 }
1330 } else {
1331 data_buf = ptr;
1332 data_size = len;
1333 ret = len;
1334 }
85f07f22
FB
1335 ptr += ret;
1336 len -= ret;
1337
10d104e4
PG
1338 buffer_to_free = 0;
1339 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1340 pre_process_video_frame(ist, &picture, &buffer_to_free);
1341 }
1342
ec5517d5
FB
1343 ist->frame_decoded = 1;
1344
1345#if 0
1346 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1347 is the one of the next displayed one */
1348 /* XXX: add mpeg4 too ? */
1349 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1350 if (ist->st->codec.pict_type != B_TYPE) {
1351 INT64 tmp;
1352 tmp = ist->last_ip_pts;
1353 ist->last_ip_pts = ist->frac_pts.val;
1354 ist->frac_pts.val = tmp;
1355 }
1356 }
1357#endif
85f07f22 1358 /* transcode raw format, encode packets and output them */
ec5517d5 1359
85f07f22 1360 for(i=0;i<nb_ostreams;i++) {
ce7c56c2 1361 int frame_size;
ec5517d5 1362
85f07f22
FB
1363 ost = ost_table[i];
1364 if (ost->source_index == ist_index) {
1365 os = output_files[ost->file_index];
1366
ec5517d5
FB
1367 if (ipts != AV_NOPTS_VALUE) {
1368#if 0
1369 printf("%d: got pts=%f %f\n",
1370 i, pkt.pts / 90000.0,
1371 (ipts - ost->st->pts.val) / 90000.0);
1372#endif
1373 /* set the input output pts pairs */
1374 ost->sync_ipts = (double)ipts * is->pts_num /
1375 is->pts_den;
1376 /* XXX: take into account the various fifos,
1377 in particular for audio */
1378 ost->sync_opts = ost->st->pts.val;
10d104e4
PG
1379 //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt.pts=%lld\n", ipts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt.pts);
1380 } else {
1381 //printf("pts.val=%lld\n", ost->st->pts.val);
be4ce157 1382 ost->sync_ipts = AV_NOPTS_VALUE;
ec5517d5
FB
1383 }
1384
85f07f22
FB
1385 if (ost->encoding_needed) {
1386 switch(ost->st->codec.codec_type) {
1387 case CODEC_TYPE_AUDIO:
1388 do_audio_out(os, ost, ist, data_buf, data_size);
1389 break;
1390 case CODEC_TYPE_VIDEO:
ec5517d5
FB
1391 /* find an audio stream for synchro */
1392 {
1393 int i;
1394 AVOutputStream *audio_sync, *ost1;
1395 audio_sync = NULL;
1396 for(i=0;i<nb_ostreams;i++) {
1397 ost1 = ost_table[i];
1398 if (ost1->file_index == ost->file_index &&
1399 ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1400 audio_sync = ost1;
1401 break;
1402 }
1403 }
1404
1405 do_video_out(os, ost, ist, &picture, &frame_size, audio_sync);
204c0f48 1406 if (do_vstats && frame_size)
ec5517d5
FB
1407 do_video_stats(os, ost, frame_size);
1408 }
85f07f22 1409 break;
51bd4565 1410 default:
c04643a2 1411 av_abort();
85f07f22
FB
1412 }
1413 } else {
18531e52
MN
1414 AVFrame avframe;
1415
85f07f22 1416 /* no reencoding needed : output the packet directly */
10bb7023 1417 /* force the input stream PTS */
18531e52
MN
1418
1419 //XXX/FIXME set keyframe flag from demuxer (or optionally from decoder)
1420 memset(&avframe, 0, sizeof(AVFrame));
1421 ost->st->codec.coded_frame= &avframe;
1422
ec5517d5 1423 av_write_frame(os, ost->index, data_buf, data_size);
b2722d0a 1424 ost->st->codec.frame_number++;
9ce2f2b1 1425 ost->frame_number++;
85f07f22
FB
1426 }
1427 }
1428 }
10d104e4 1429 av_free(buffer_to_free);
ec5517d5 1430 ipts = AV_NOPTS_VALUE;
85f07f22 1431 }
bf5af568 1432 discard_packet:
85f07f22
FB
1433 av_free_packet(&pkt);
1434
ec5517d5
FB
1435 /* dump report by using the output first video and audio streams */
1436 print_report(output_files, ost_table, nb_ostreams, 0);
85f07f22 1437 }
a38469e1 1438 term_exit();
85f07f22
FB
1439
1440 /* dump report by using the first video and audio streams */
ec5517d5
FB
1441 print_report(output_files, ost_table, nb_ostreams, 1);
1442
85f07f22
FB
1443 /* close each encoder */
1444 for(i=0;i<nb_ostreams;i++) {
1445 ost = ost_table[i];
1446 if (ost->encoding_needed) {
5abdb4b1 1447 av_freep(&ost->st->codec.stats_in);
85f07f22
FB
1448 avcodec_close(&ost->st->codec);
1449 }
1450 }
1451
1452 /* close each decoder */
1453 for(i=0;i<nb_istreams;i++) {
1454 ist = ist_table[i];
1455 if (ist->decoding_needed) {
1456 avcodec_close(&ist->st->codec);
1457 }
1458 }
1459
1460
1461 /* write the trailer if needed and close file */
1462 for(i=0;i<nb_output_files;i++) {
1463 os = output_files[i];
79fdaa4c 1464 av_write_trailer(os);
85f07f22
FB
1465 }
1466 /* finished ! */
1467
1468 ret = 0;
1469 fail1:
0f1578af 1470 av_free(file_table);
bdc4796f 1471
85f07f22
FB
1472 if (ist_table) {
1473 for(i=0;i<nb_istreams;i++) {
1474 ist = ist_table[i];
0f1578af 1475 av_free(ist);
85f07f22 1476 }
0f1578af 1477 av_free(ist_table);
85f07f22
FB
1478 }
1479 if (ost_table) {
1480 for(i=0;i<nb_ostreams;i++) {
1481 ost = ost_table[i];
1482 if (ost) {
5abdb4b1
FB
1483 if (ost->logfile) {
1484 fclose(ost->logfile);
1485 ost->logfile = NULL;
1486 }
bf5af568
FB
1487 fifo_free(&ost->fifo); /* works even if fifo is not
1488 initialized but set to zero */
0f1578af 1489 av_free(ost->pict_tmp.data[0]);
85f07f22
FB
1490 if (ost->video_resample)
1491 img_resample_close(ost->img_resample_ctx);
1492 if (ost->audio_resample)
1493 audio_resample_close(ost->resample);
0f1578af 1494 av_free(ost);
85f07f22
FB
1495 }
1496 }
0f1578af 1497 av_free(ost_table);
85f07f22
FB
1498 }
1499 return ret;
1500 fail:
1501 ret = -ENOMEM;
1502 goto fail1;
1503}
1504
1505#if 0
1506int file_read(const char *filename)
1507{
1508 URLContext *h;
1509 unsigned char buffer[1024];
1510 int len, i;
1511
1512 if (url_open(&h, filename, O_RDONLY) < 0) {
1513 printf("could not open '%s'\n", filename);
1514 return -1;
1515 }
1516 for(;;) {
1517 len = url_read(h, buffer, sizeof(buffer));
1518 if (len <= 0)
1519 break;
1520 for(i=0;i<len;i++) putchar(buffer[i]);
1521 }
1522 url_close(h);
1523 return 0;
1524}
1525#endif
1526
1527void show_licence(void)
1528{
1529 printf(
1530 "ffmpeg version " FFMPEG_VERSION "\n"
bf5af568
FB
1531 "Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n"
1532 "This library is free software; you can redistribute it and/or\n"
1533 "modify it under the terms of the GNU Lesser General Public\n"
1534 "License as published by the Free Software Foundation; either\n"
1535 "version 2 of the License, or (at your option) any later version.\n"
85f07f22 1536 "\n"
bf5af568 1537 "This library is distributed in the hope that it will be useful,\n"
85f07f22 1538 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
bf5af568
FB
1539 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
1540 "Lesser General Public License for more details.\n"
85f07f22 1541 "\n"
bf5af568
FB
1542 "You should have received a copy of the GNU Lesser General Public\n"
1543 "License along with this library; if not, write to the Free Software\n"
1544 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
85f07f22
FB
1545 );
1546 exit(1);
1547}
1548
817b23ff
FB
1549void opt_image_format(const char *arg)
1550{
1551 AVImageFormat *f;
1552
1553 for(f = first_image_format; f != NULL; f = f->next) {
1554 if (!strcmp(arg, f->name))
1555 break;
1556 }
1557 if (!f) {
1558 fprintf(stderr, "Unknown image format: '%s'\n", arg);
1559 exit(1);
1560 }
1561 image_format = f;
1562}
1563
85f07f22
FB
1564void opt_format(const char *arg)
1565{
817b23ff
FB
1566 /* compatibility stuff for pgmyuv */
1567 if (!strcmp(arg, "pgmyuv")) {
1568 opt_image_format(arg);
1569 arg = "image";
1570 }
1571
79fdaa4c
FB
1572 file_iformat = av_find_input_format(arg);
1573 file_oformat = guess_format(arg, NULL, NULL);
1574 if (!file_iformat && !file_oformat) {
1575 fprintf(stderr, "Unknown input or output format: %s\n", arg);
85f07f22
FB
1576 exit(1);
1577 }
85f07f22
FB
1578}
1579
1580void opt_video_bitrate(const char *arg)
1581{
1582 video_bit_rate = atoi(arg) * 1000;
1583}
1584
9cdd6a24
MN
1585void opt_video_bitrate_tolerance(const char *arg)
1586{
1587 video_bit_rate_tolerance = atoi(arg) * 1000;
1588}
1589
3aa102be
MN
1590void opt_video_bitrate_max(const char *arg)
1591{
1592 video_rc_max_rate = atoi(arg) * 1000;
1593}
1594
1595void opt_video_bitrate_min(const char *arg)
1596{
1597 video_rc_min_rate = atoi(arg) * 1000;
1598}
1599
946c8a12
MN
1600void opt_video_buffer_size(const char *arg)
1601{
1602 video_rc_buffer_size = atoi(arg) * 1000;
1603}
1604
3aa102be
MN
1605void opt_video_rc_eq(char *arg)
1606{
1607 video_rc_eq = arg;
1608}
1609
ac2830ec
MN
1610void opt_video_rc_override_string(char *arg)
1611{
1612 video_rc_override_string = arg;
1613}
1614
3aa102be 1615
fe670d09
MN
1616void opt_workaround_bugs(const char *arg)
1617{
1618 workaround_bugs = atoi(arg);
1619}
1620
463678ac
MN
1621void opt_dct_algo(const char *arg)
1622{
1623 dct_algo = atoi(arg);
1624}
1625
2ad1516a
MN
1626void opt_idct_algo(const char *arg)
1627{
1628 idct_algo = atoi(arg);
1629}
1630
1631
8409b8fe
MN
1632void opt_error_resilience(const char *arg)
1633{
1634 error_resilience = atoi(arg);
1635}
1636
4d2858de
MN
1637void opt_error_concealment(const char *arg)
1638{
1639 error_concealment = atoi(arg);
1640}
1641
59b571c1
MN
1642void opt_debug(const char *arg)
1643{
1644 debug = atoi(arg);
1645}
4d2858de 1646
85f07f22
FB
1647void opt_frame_rate(const char *arg)
1648{
1649 frame_rate = (int)(strtod(arg, 0) * FRAME_RATE_BASE);
1650}
1651
ab6d194a
MN
1652
1653void opt_frame_crop_top(const char *arg)
1654{
1655 frame_topBand = atoi(arg);
1656 if (frame_topBand < 0) {
1657 fprintf(stderr, "Incorrect top crop size\n");
1658 exit(1);
1659 }
1660 if ((frame_topBand % 2) != 0) {
1661 fprintf(stderr, "Top crop size must be a multiple of 2\n");
1662 exit(1);
1663 }
1664 if ((frame_topBand) >= frame_height){
1665 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1666 exit(1);
1667 }
1668 frame_height -= frame_topBand;
1669}
1670
1671void opt_frame_crop_bottom(const char *arg)
1672{
1673 frame_bottomBand = atoi(arg);
1674 if (frame_bottomBand < 0) {
1675 fprintf(stderr, "Incorrect bottom crop size\n");
1676 exit(1);
1677 }
1678 if ((frame_bottomBand % 2) != 0) {
1679 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
1680 exit(1);
1681 }
1682 if ((frame_bottomBand) >= frame_height){
1683 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1684 exit(1);
1685 }
1686 frame_height -= frame_bottomBand;
1687}
1688
1689void opt_frame_crop_left(const char *arg)
1690{
1691 frame_leftBand = atoi(arg);
1692 if (frame_leftBand < 0) {
1693 fprintf(stderr, "Incorrect left crop size\n");
1694 exit(1);
1695 }
1696 if ((frame_leftBand % 2) != 0) {
1697 fprintf(stderr, "Left crop size must be a multiple of 2\n");
1698 exit(1);
1699 }
1700 if ((frame_leftBand) >= frame_width){
1701 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1702 exit(1);
1703 }
1704 frame_width -= frame_leftBand;
1705}
1706
1707void opt_frame_crop_right(const char *arg)
1708{
1709 frame_rightBand = atoi(arg);
1710 if (frame_rightBand < 0) {
1711 fprintf(stderr, "Incorrect right crop size\n");
1712 exit(1);
1713 }
1714 if ((frame_rightBand % 2) != 0) {
1715 fprintf(stderr, "Right crop size must be a multiple of 2\n");
1716 exit(1);
1717 }
1718 if ((frame_rightBand) >= frame_width){
1719 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1720 exit(1);
1721 }
1722 frame_width -= frame_rightBand;
1723}
1724
85f07f22
FB
1725void opt_frame_size(const char *arg)
1726{
1727 parse_image_size(&frame_width, &frame_height, arg);
1728 if (frame_width <= 0 || frame_height <= 0) {
1729 fprintf(stderr, "Incorrect frame size\n");
1730 exit(1);
1731 }
1732 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
1733 fprintf(stderr, "Frame size must be a multiple of 2\n");
1734 exit(1);
1735 }
1736}
1737
1738void opt_gop_size(const char *arg)
1739{
1740 gop_size = atoi(arg);
1741}
1742
bc6caae2
J
1743void opt_b_frames(const char *arg)
1744{
1745 b_frames = atoi(arg);
1746 if (b_frames > FF_MAX_B_FRAMES) {
1747 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
1748 exit(1);
1749 } else if (b_frames < 1) {
1750 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
1751 exit(1);
1752 }
1753}
1754
85f07f22
FB
1755void opt_qscale(const char *arg)
1756{
1757 video_qscale = atoi(arg);
1758 if (video_qscale < 0 ||
1759 video_qscale > 31) {
1760 fprintf(stderr, "qscale must be >= 1 and <= 31\n");
1761 exit(1);
1762 }
1763}
1764
9cdd6a24
MN
1765void opt_qmin(const char *arg)
1766{
1767 video_qmin = atoi(arg);
1768 if (video_qmin < 0 ||
1769 video_qmin > 31) {
1770 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
1771 exit(1);
1772 }
1773}
1774
1775void opt_qmax(const char *arg)
1776{
1777 video_qmax = atoi(arg);
1778 if (video_qmax < 0 ||
1779 video_qmax > 31) {
1780 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
1781 exit(1);
1782 }
1783}
1784
17a70fde
MN
1785void opt_mb_qmin(const char *arg)
1786{
1787 video_mb_qmin = atoi(arg);
1788 if (video_mb_qmin < 0 ||
1789 video_mb_qmin > 31) {
1790 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
1791 exit(1);
1792 }
1793}
1794
1795void opt_mb_qmax(const char *arg)
1796{
1797 video_mb_qmax = atoi(arg);
1798 if (video_mb_qmax < 0 ||
1799 video_mb_qmax > 31) {
1800 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
1801 exit(1);
1802 }
1803}
1804
9cdd6a24
MN
1805void opt_qdiff(const char *arg)
1806{
1807 video_qdiff = atoi(arg);
1808 if (video_qdiff < 0 ||
1809 video_qdiff > 31) {
1810 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
1811 exit(1);
1812 }
1813}
1814
1815void opt_qblur(const char *arg)
1816{
1817 video_qblur = atof(arg);
1818}
1819
1820void opt_qcomp(const char *arg)
1821{
1822 video_qcomp = atof(arg);
1823}
85f07f22 1824
ac2830ec
MN
1825void opt_rc_initial_cplx(const char *arg)
1826{
1827 video_rc_initial_cplx = atof(arg);
1828}
29700fa6
MN
1829void opt_b_qfactor(const char *arg)
1830{
1831 video_b_qfactor = atof(arg);
1832}
1833void opt_i_qfactor(const char *arg)
1834{
1835 video_i_qfactor = atof(arg);
1836}
1837void opt_b_qoffset(const char *arg)
1838{
1839 video_b_qoffset = atof(arg);
1840}
1841void opt_i_qoffset(const char *arg)
1842{
1843 video_i_qoffset = atof(arg);
1844}
1845
1dbb6d90
MN
1846void opt_packet_size(const char *arg)
1847{
1848 packet_size= atoi(arg);
1849}
1850
f560dd82
MN
1851void opt_strict(const char *arg)
1852{
1853 strict= atoi(arg);
1854}
1855
85f07f22
FB
1856void opt_audio_bitrate(const char *arg)
1857{
1858 audio_bit_rate = atoi(arg) * 1000;
1859}
1860
1861void opt_audio_rate(const char *arg)
1862{
1863 audio_sample_rate = atoi(arg);
1864}
1865
1866void opt_audio_channels(const char *arg)
1867{
1868 audio_channels = atoi(arg);
1869}
1870
1871void opt_video_device(const char *arg)
1872{
e9a9e0c2 1873 video_device = av_strdup(arg);
85f07f22
FB
1874}
1875
a5df11ab
FB
1876void opt_video_channel(const char *arg)
1877{
1878 video_channel = strtol(arg, NULL, 0);
1879}
1880
85f07f22
FB
1881void opt_audio_device(const char *arg)
1882{
e9a9e0c2 1883 audio_device = av_strdup(arg);
85f07f22
FB
1884}
1885
8aa3ee32
MK
1886void opt_dv1394(const char *arg)
1887{
1888 video_grab_format = "dv1394";
1501987b 1889 audio_grab_format = NULL;
8aa3ee32
MK
1890}
1891
85f07f22
FB
1892void opt_audio_codec(const char *arg)
1893{
1894 AVCodec *p;
1895
1629626f
FB
1896 if (!strcmp(arg, "copy")) {
1897 audio_stream_copy = 1;
85f07f22 1898 } else {
1629626f
FB
1899 p = first_avcodec;
1900 while (p) {
1901 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
1902 break;
1903 p = p->next;
1904 }
1905 if (p == NULL) {
1906 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
1907 exit(1);
1908 } else {
1909 audio_codec_id = p->id;
1910 }
85f07f22
FB
1911 }
1912}
1913
10d104e4
PG
1914void add_frame_hooker(const char *arg)
1915{
1916 int argc = 0;
1917 char *argv[64];
1918 int i;
e9a9e0c2 1919 char *args = av_strdup(arg);
10d104e4
PG
1920
1921 argv[0] = strtok(args, " ");
1922 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
1923 }
1924
1925 i = frame_hook_add(argc, argv);
1926
1927 if (i != 0) {
1928 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
1929 exit(1);
1930 }
1931}
1932
85f07f22
FB
1933const char *motion_str[] = {
1934 "zero",
1935 "full",
1936 "log",
1937 "phods",
7084c149
MN
1938 "epzs",
1939 "x1",
85f07f22
FB
1940 NULL,
1941};
1942
1943void opt_motion_estimation(const char *arg)
1944{
1945 const char **p;
1946 p = motion_str;
1947 for(;;) {
1948 if (!*p) {
1949 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
1950 exit(1);
1951 }
1952 if (!strcmp(*p, arg))
1953 break;
1954 p++;
1955 }
101bea5f 1956 me_method = (p - motion_str) + 1;
85f07f22
FB
1957}
1958
1959void opt_video_codec(const char *arg)
1960{
1961 AVCodec *p;
1962
1629626f
FB
1963 if (!strcmp(arg, "copy")) {
1964 video_stream_copy = 1;
85f07f22 1965 } else {
1629626f
FB
1966 p = first_avcodec;
1967 while (p) {
1968 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
1969 break;
1970 p = p->next;
1971 }
1972 if (p == NULL) {
1973 fprintf(stderr, "Unknown video codec '%s'\n", arg);
1974 exit(1);
1975 } else {
1976 video_codec_id = p->id;
1977 }
85f07f22
FB
1978 }
1979}
1980
1981void opt_map(const char *arg)
1982{
1983 AVStreamMap *m;
1984 const char *p;
1985
1986 p = arg;
1987 m = &stream_maps[nb_stream_maps++];
1988
1989 m->file_index = strtol(arg, (char **)&p, 0);
1990 if (*p)
1991 p++;
a5dc85ef
J
1992
1993 m->stream_index = strtol(p, (char **)&p, 0);
85f07f22
FB
1994}
1995
1996void opt_recording_time(const char *arg)
1997{
1998 recording_time = parse_date(arg, 1);
1999}
2000
79fdaa4c 2001void print_error(const char *filename, int err)
919f448d 2002{
79fdaa4c
FB
2003 switch(err) {
2004 case AVERROR_NUMEXPECTED:
919f448d
FB
2005 fprintf(stderr, "%s: Incorrect image filename syntax.\n"
2006 "Use '%%d' to specify the image number:\n"
2007 " for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
2008 " for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
2009 filename);
79fdaa4c
FB
2010 break;
2011 case AVERROR_INVALIDDATA:
2012 fprintf(stderr, "%s: Error while parsing header\n", filename);
2013 break;
2014 case AVERROR_NOFMT:
2015 fprintf(stderr, "%s: Unknown format\n", filename);
2016 break;
2017 default:
2018 fprintf(stderr, "%s: Error while opening file\n", filename);
2019 break;
919f448d
FB
2020 }
2021}
85f07f22
FB
2022
2023void opt_input_file(const char *filename)
2024{
2025 AVFormatContext *ic;
2026 AVFormatParameters params, *ap = &params;
6dc96cb0 2027 int err, i, ret, rfps;
85f07f22 2028
b242baa4
FB
2029 if (!strcmp(filename, "-"))
2030 filename = "pipe:";
2031
85f07f22 2032 /* get default parameters from command line */
79fdaa4c
FB
2033 memset(ap, 0, sizeof(*ap));
2034 ap->sample_rate = audio_sample_rate;
2035 ap->channels = audio_channels;
2036 ap->frame_rate = frame_rate;
2037 ap->width = frame_width;
2038 ap->height = frame_height;
817b23ff 2039 ap->image_format = image_format;
79fdaa4c
FB
2040
2041 /* open the input file with generic libav function */
2042 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
85f07f22 2043 if (err < 0) {
79fdaa4c 2044 print_error(filename, err);
85f07f22
FB
2045 exit(1);
2046 }
2047
79fdaa4c
FB
2048 /* If not enough info to get the stream parameters, we decode the
2049 first frames to get it. (used in mpeg case for example) */
2050 ret = av_find_stream_info(ic);
85f07f22
FB
2051 if (ret < 0) {
2052 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2053 exit(1);
2054 }
2055
2056 /* update the current parameters so that they match the one of the input stream */
2057 for(i=0;i<ic->nb_streams;i++) {
2058 AVCodecContext *enc = &ic->streams[i]->codec;
2059 switch(enc->codec_type) {
2060 case CODEC_TYPE_AUDIO:
e0d2714a 2061 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
85f07f22
FB
2062 audio_channels = enc->channels;
2063 audio_sample_rate = enc->sample_rate;
2064 break;
2065 case CODEC_TYPE_VIDEO:
2066 frame_height = enc->height;
2067 frame_width = enc->width;
79fdaa4c 2068 rfps = ic->streams[i]->r_frame_rate;
fe670d09 2069 enc->workaround_bugs = workaround_bugs;
8409b8fe 2070 enc->error_resilience = error_resilience;
4d2858de 2071 enc->error_concealment = error_concealment;
2ad1516a 2072 enc->idct_algo= idct_algo;
59b571c1 2073 enc->debug= debug;
d7425f59
MN
2074/* if(enc->codec->capabilities & CODEC_CAP_TRUNCATED)
2075 enc->flags|= CODEC_FLAG_TRUNCATED; */
2076 if(/*enc->codec_id==CODEC_ID_MPEG4 || */enc->codec_id==CODEC_ID_MPEG1VIDEO)
2077 enc->flags|= CODEC_FLAG_TRUNCATED;
2078
79fdaa4c 2079 if (enc->frame_rate != rfps) {
6dc96cb0
J
2080 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2081 i, (float)enc->frame_rate / FRAME_RATE_BASE,
2082 (float)rfps / FRAME_RATE_BASE);
79fdaa4c 2083 }
bf5af568
FB
2084 /* update the current frame rate to match the stream frame rate */
2085 frame_rate = rfps;
85f07f22 2086 break;
51bd4565 2087 default:
c04643a2 2088 av_abort();
85f07f22
FB
2089 }
2090 }
2091
2092 input_files[nb_input_files] = ic;
2093 /* dump the file content */
2094 dump_format(ic, nb_input_files, filename, 0);
2095 nb_input_files++;
79fdaa4c
FB
2096 file_iformat = NULL;
2097 file_oformat = NULL;
817b23ff 2098 image_format = NULL;
85f07f22
FB
2099}
2100
919f448d
FB
2101void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2102{
2103 int has_video, has_audio, i, j;
2104 AVFormatContext *ic;
2105
2106 has_video = 0;
2107 has_audio = 0;
2108 for(j=0;j<nb_input_files;j++) {
2109 ic = input_files[j];
2110 for(i=0;i<ic->nb_streams;i++) {
2111 AVCodecContext *enc = &ic->streams[i]->codec;
2112 switch(enc->codec_type) {
2113 case CODEC_TYPE_AUDIO:
2114 has_audio = 1;
2115 break;
2116 case CODEC_TYPE_VIDEO:
2117 has_video = 1;
2118 break;
51bd4565 2119 default:
c04643a2 2120 av_abort();
919f448d
FB
2121 }
2122 }
2123 }
2124 *has_video_ptr = has_video;
2125 *has_audio_ptr = has_audio;
2126}
2127
85f07f22
FB
2128void opt_output_file(const char *filename)
2129{
2130 AVStream *st;
2131 AVFormatContext *oc;
919f448d 2132 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
85f07f22 2133 int codec_id;
817b23ff 2134 AVFormatParameters params, *ap = &params;
85f07f22
FB
2135
2136 if (!strcmp(filename, "-"))
2137 filename = "pipe:";
2138
2139 oc = av_mallocz(sizeof(AVFormatContext));
2140
79fdaa4c
FB
2141 if (!file_oformat) {
2142 file_oformat = guess_format(NULL, filename, NULL);
2143 if (!file_oformat) {
2144 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2145 filename);
2146 exit(1);
2147 }
85f07f22
FB
2148 }
2149
79fdaa4c 2150 oc->oformat = file_oformat;
85f07f22 2151
79fdaa4c 2152 if (!strcmp(file_oformat->name, "ffm") &&
85f07f22
FB
2153 strstart(filename, "http:", NULL)) {
2154 /* special case for files sent to ffserver: we get the stream
2155 parameters from ffserver */
2156 if (read_ffserver_streams(oc, filename) < 0) {
2157 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2158 exit(1);
2159 }
2160 } else {
79fdaa4c
FB
2161 use_video = file_oformat->video_codec != CODEC_ID_NONE;
2162 use_audio = file_oformat->audio_codec != CODEC_ID_NONE;
919f448d 2163
e30a2846
FB
2164 /* disable if no corresponding type found and at least one
2165 input file */
2166 if (nb_input_files > 0) {
2167 check_audio_video_inputs(&input_has_video, &input_has_audio);
2168 if (!input_has_video)
2169 use_video = 0;
2170 if (!input_has_audio)
2171 use_audio = 0;
2172 }
919f448d
FB
2173
2174 /* manual disable */
85f07f22
FB
2175 if (audio_disable) {
2176 use_audio = 0;
2177 }
2178 if (video_disable) {
2179 use_video = 0;
2180 }
2181
2182 nb_streams = 0;
2183 if (use_video) {
2184 AVCodecContext *video_enc;
2185
2186 st = av_mallocz(sizeof(AVStream));
2187 if (!st) {
2188 fprintf(stderr, "Could not alloc stream\n");
2189 exit(1);
2190 }
1e491e29 2191 avcodec_get_context_defaults(&st->codec);
85f07f22 2192
1629626f
FB
2193 video_enc = &st->codec;
2194 if (video_stream_copy) {
2195 st->stream_copy = 1;
2196 video_enc->codec_type = CODEC_TYPE_VIDEO;
2197 } else {
ac2830ec
MN
2198 char *p;
2199 int i;
2200
1629626f
FB
2201 codec_id = file_oformat->video_codec;
2202 if (video_codec_id != CODEC_ID_NONE)
2203 codec_id = video_codec_id;
2204
2205 video_enc->codec_id = codec_id;
2206
2207 video_enc->bit_rate = video_bit_rate;
2208 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2209 video_enc->frame_rate = frame_rate;
2210
2211 video_enc->width = frame_width;
2212 video_enc->height = frame_height;
2213
2214 if (!intra_only)
2215 video_enc->gop_size = gop_size;
2216 else
2217 video_enc->gop_size = 0;
2218 if (video_qscale || same_quality) {
2219 video_enc->flags |= CODEC_FLAG_QSCALE;
1e491e29 2220 st->quality = video_qscale;
1629626f 2221 }
9cdd6a24 2222
1629626f
FB
2223 if (use_hq) {
2224 video_enc->flags |= CODEC_FLAG_HQ;
2225 }
e4986da9 2226
1629626f
FB
2227 if (use_4mv) {
2228 video_enc->flags |= CODEC_FLAG_HQ;
2229 video_enc->flags |= CODEC_FLAG_4MV;
2230 }
bc6caae2 2231
1629626f
FB
2232 if(use_part)
2233 video_enc->flags |= CODEC_FLAG_PART;
1dbb6d90
MN
2234
2235
1629626f 2236 if (b_frames) {
1629626f
FB
2237 video_enc->max_b_frames = b_frames;
2238 video_enc->b_frame_strategy = 0;
2239 video_enc->b_quant_factor = 2.0;
bc6caae2 2240 }
bc6caae2 2241
1629626f
FB
2242 video_enc->qmin = video_qmin;
2243 video_enc->qmax = video_qmax;
17a70fde
MN
2244 video_enc->mb_qmin = video_mb_qmin;
2245 video_enc->mb_qmax = video_mb_qmax;
1629626f
FB
2246 video_enc->max_qdiff = video_qdiff;
2247 video_enc->qblur = video_qblur;
2248 video_enc->qcompress = video_qcomp;
2249 video_enc->rc_eq = video_rc_eq;
59b571c1 2250 video_enc->debug= debug;
ac2830ec
MN
2251
2252 p= video_rc_override_string;
2253 for(i=0; p; i++){
2254 int start, end, q;
2255 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2256 if(e!=3){
2257 fprintf(stderr, "error parsing rc_override\n");
2258 exit(1);
2259 }
2260 video_enc->rc_override=
47e2a6e6
FB
2261 av_realloc(video_enc->rc_override,
2262 sizeof(RcOverride)*(i+1));
ac2830ec
MN
2263 video_enc->rc_override[i].start_frame= start;
2264 video_enc->rc_override[i].end_frame = end;
2265 if(q>0){
2266 video_enc->rc_override[i].qscale= q;
2267 video_enc->rc_override[i].quality_factor= 1.0;
2268 }
2269 else{
2270 video_enc->rc_override[i].qscale= 0;
2271 video_enc->rc_override[i].quality_factor= -q/100.0;
2272 }
2273 p= strchr(p, '/');
2274 if(p) p++;
2275 }
2276 video_enc->rc_override_count=i;
2277
1629626f
FB
2278 video_enc->rc_max_rate = video_rc_max_rate;
2279 video_enc->rc_min_rate = video_rc_min_rate;
2280 video_enc->rc_buffer_size = video_rc_buffer_size;
2281 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
ac2830ec 2282 video_enc->rc_initial_cplx= video_rc_initial_cplx;
1629626f
FB
2283 video_enc->i_quant_factor = video_i_qfactor;
2284 video_enc->b_quant_factor = video_b_qfactor;
2285 video_enc->i_quant_offset = video_i_qoffset;
2286 video_enc->b_quant_offset = video_b_qoffset;
2287 video_enc->dct_algo = dct_algo;
2288 video_enc->idct_algo = idct_algo;
f560dd82 2289 video_enc->strict_std_compliance = strict;
1629626f
FB
2290 if(packet_size){
2291 video_enc->rtp_mode= 1;
2292 video_enc->rtp_payload_size= packet_size;
2293 }
9cdd6a24 2294
1629626f 2295 if (do_psnr)
140cb663 2296 video_enc->flags|= CODEC_FLAG_PSNR;
e4986da9 2297
1629626f 2298 video_enc->me_method = me_method;
5abdb4b1 2299
1629626f
FB
2300 /* two pass mode */
2301 if (do_pass) {
2302 if (do_pass == 1) {
2303 video_enc->flags |= CODEC_FLAG_PASS1;
2304 } else {
2305 video_enc->flags |= CODEC_FLAG_PASS2;
2306 }
5abdb4b1 2307 }
cfcf0ffd 2308 }
85f07f22
FB
2309 oc->streams[nb_streams] = st;
2310 nb_streams++;
2311 }
2312
2313 if (use_audio) {
2314 AVCodecContext *audio_enc;
2315
2316 st = av_mallocz(sizeof(AVStream));
2317 if (!st) {
2318 fprintf(stderr, "Could not alloc stream\n");
2319 exit(1);
2320 }
1e491e29 2321 avcodec_get_context_defaults(&st->codec);
1629626f 2322
85f07f22 2323 audio_enc = &st->codec;
85f07f22 2324 audio_enc->codec_type = CODEC_TYPE_AUDIO;
1629626f
FB
2325 if (audio_stream_copy) {
2326 st->stream_copy = 1;
2327 } else {
2328 codec_id = file_oformat->audio_codec;
2329 if (audio_codec_id != CODEC_ID_NONE)
2330 codec_id = audio_codec_id;
2331 audio_enc->codec_id = codec_id;
2332
2333 audio_enc->bit_rate = audio_bit_rate;
2334 audio_enc->sample_rate = audio_sample_rate;
2335 /* For audio codecs other than AC3 we limit */
2336 /* the number of coded channels to stereo */
2337 if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
2338 audio_enc->channels = 2;
2339 } else
2340 audio_enc->channels = audio_channels;
2341 }
85f07f22
FB
2342 oc->streams[nb_streams] = st;
2343 nb_streams++;
2344 }
2345
2346 oc->nb_streams = nb_streams;
2347
2348 if (!nb_streams) {
919f448d 2349 fprintf(stderr, "No audio or video streams available\n");
85f07f22
FB
2350 exit(1);
2351 }
2352
2353 if (str_title)
79fdaa4c 2354 pstrcpy(oc->title, sizeof(oc->title), str_title);
85f07f22 2355 if (str_author)
79fdaa4c 2356 pstrcpy(oc->author, sizeof(oc->author), str_author);
85f07f22 2357 if (str_copyright)
79fdaa4c 2358 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
85f07f22 2359 if (str_comment)
79fdaa4c 2360 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
85f07f22
FB
2361 }
2362
1629626f 2363 output_files[nb_output_files++] = oc;
85f07f22
FB
2364
2365 strcpy(oc->filename, filename);
919f448d
FB
2366
2367 /* check filename in case of an image number is expected */
79fdaa4c
FB
2368 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2369 if (filename_number_test(oc->filename) < 0) {
2370 print_error(oc->filename, AVERROR_NUMEXPECTED);
919f448d 2371 exit(1);
79fdaa4c 2372 }
919f448d
FB
2373 }
2374
79fdaa4c 2375 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
85f07f22
FB
2376 /* test if it already exists to avoid loosing precious files */
2377 if (!file_overwrite &&
2378 (strchr(filename, ':') == NULL ||
2379 strstart(filename, "file:", NULL))) {
2380 if (url_exist(filename)) {
2381 int c;
2382
2383 printf("File '%s' already exists. Overwrite ? [y/N] ", filename);
2384 fflush(stdout);
2385 c = getchar();
2386 if (toupper(c) != 'Y') {
2387 fprintf(stderr, "Not overwriting - exiting\n");
2388 exit(1);
2389 }
2390 }
2391 }
2392
2393 /* open the file */
2394 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
2395 fprintf(stderr, "Could not open '%s'\n", filename);
2396 exit(1);
2397 }
2398 }
2399
817b23ff
FB
2400 memset(ap, 0, sizeof(*ap));
2401 ap->image_format = image_format;
2402 if (av_set_parameters(oc, ap) < 0) {
2403 fprintf(stderr, "%s: Invalid encoding parameters\n",
2404 oc->filename);
2405 exit(1);
2406 }
2407
85f07f22 2408 /* reset some options */
79fdaa4c
FB
2409 file_oformat = NULL;
2410 file_iformat = NULL;
817b23ff 2411 image_format = NULL;
85f07f22
FB
2412 audio_disable = 0;
2413 video_disable = 0;
2414 audio_codec_id = CODEC_ID_NONE;
2415 video_codec_id = CODEC_ID_NONE;
1629626f
FB
2416 audio_stream_copy = 0;
2417 video_stream_copy = 0;
85f07f22
FB
2418}
2419
a38469e1
FB
2420/* prepare dummy protocols for grab */
2421void prepare_grab(void)
2422{
2423 int has_video, has_audio, i, j;
2424 AVFormatContext *oc;
2425 AVFormatContext *ic;
79a7c268 2426 AVFormatParameters vp1, *vp = &vp1;
a38469e1 2427 AVFormatParameters ap1, *ap = &ap1;
79a7c268 2428
a38469e1
FB
2429 /* see if audio/video inputs are needed */
2430 has_video = 0;
2431 has_audio = 0;
2432 memset(ap, 0, sizeof(*ap));
79a7c268 2433 memset(vp, 0, sizeof(*vp));
a38469e1
FB
2434 for(j=0;j<nb_output_files;j++) {
2435 oc = output_files[j];
2436 for(i=0;i<oc->nb_streams;i++) {
2437 AVCodecContext *enc = &oc->streams[i]->codec;
2438 switch(enc->codec_type) {
2439 case CODEC_TYPE_AUDIO:
2440 if (enc->sample_rate > ap->sample_rate)
2441 ap->sample_rate = enc->sample_rate;
2442 if (enc->channels > ap->channels)
2443 ap->channels = enc->channels;
2444 has_audio = 1;
2445 break;
2446 case CODEC_TYPE_VIDEO:
79a7c268
FB
2447 if (enc->width > vp->width)
2448 vp->width = enc->width;
2449 if (enc->height > vp->height)
2450 vp->height = enc->height;
2451 if (enc->frame_rate > vp->frame_rate)
2452 vp->frame_rate = enc->frame_rate;
a38469e1
FB
2453 has_video = 1;
2454 break;
51bd4565 2455 default:
c04643a2 2456 av_abort();
a38469e1
FB
2457 }
2458 }
2459 }
2460
2461 if (has_video == 0 && has_audio == 0) {
2462 fprintf(stderr, "Output file must have at least one audio or video stream\n");
2463 exit(1);
2464 }
2465
2466 if (has_video) {
79fdaa4c 2467 AVInputFormat *fmt1;
8aa3ee32 2468 fmt1 = av_find_input_format(video_grab_format);
a5df11ab
FB
2469 vp->device = video_device;
2470 vp->channel = video_channel;
79a7c268 2471 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
bf5af568 2472 fprintf(stderr, "Could not find video grab device\n");
a38469e1
FB
2473 exit(1);
2474 }
79fdaa4c 2475 /* by now video grab has one stream */
79a7c268 2476 ic->streams[0]->r_frame_rate = vp->frame_rate;
a38469e1 2477 input_files[nb_input_files] = ic;
79a7c268 2478 dump_format(ic, nb_input_files, "", 0);
a38469e1
FB
2479 nb_input_files++;
2480 }
1501987b 2481 if (has_audio && audio_grab_format) {
79fdaa4c 2482 AVInputFormat *fmt1;
8aa3ee32 2483 fmt1 = av_find_input_format(audio_grab_format);
79a7c268 2484 ap->device = audio_device;
79fdaa4c 2485 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
bf5af568 2486 fprintf(stderr, "Could not find audio grab device\n");
a38469e1
FB
2487 exit(1);
2488 }
2489 input_files[nb_input_files] = ic;
79a7c268 2490 dump_format(ic, nb_input_files, "", 0);
a38469e1
FB
2491 nb_input_files++;
2492 }
2493}
2494
a38469e1
FB
2495/* open the necessary output devices for playing */
2496void prepare_play(void)
2497{
79a7c268 2498 int has_video, has_audio;
a38469e1 2499
79a7c268
FB
2500 check_audio_video_inputs(&has_video, &has_audio);
2501
2502 /* manual disable */
2503 if (audio_disable) {
2504 has_audio = 0;
2505 }
2506 if (video_disable) {
2507 has_video = 0;
2508 }
2509
2510 if (has_audio) {
2511 file_oformat = guess_format("audio_device", NULL, NULL);
2512 if (!file_oformat) {
2513 fprintf(stderr, "Could not find audio device\n");
2514 exit(1);
2515 }
04bbd31b 2516 opt_output_file(audio_device?audio_device:"/dev/dsp0");
79a7c268
FB
2517 }
2518
2519 if (has_video) {
2520 file_oformat = guess_format("framebuffer_device", NULL, NULL);
2521 if (!file_oformat) {
2522 fprintf(stderr, "Could not find framebuffer device\n");
2523 exit(1);
2524 }
2525 opt_output_file("");
2526 }
a38469e1
FB
2527}
2528
5abdb4b1
FB
2529/* same option as mencoder */
2530void opt_pass(const char *pass_str)
2531{
2532 int pass;
2533 pass = atoi(pass_str);
2534 if (pass != 1 && pass != 2) {
2535 fprintf(stderr, "pass number can be only 1 or 2\n");
2536 exit(1);
2537 }
2538 do_pass = pass;
2539}
a38469e1 2540
f3ec2d46 2541#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
5727b222
FB
2542INT64 getutime(void)
2543{
f3ec2d46 2544 return av_gettime();
5727b222 2545}
bdc4796f
FB
2546#else
2547INT64 getutime(void)
2548{
f3ec2d46
SG
2549 struct rusage rusage;
2550
2551 getrusage(RUSAGE_SELF, &rusage);
2552 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
bdc4796f
FB
2553}
2554#endif
5727b222 2555
79fdaa4c
FB
2556extern int ffm_nopts;
2557
2558void opt_bitexact(void)
2559{
2560 avcodec_set_bit_exact();
2561 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2562 ffm_nopts = 1;
2563}
2564
85f07f22
FB
2565void show_formats(void)
2566{
79fdaa4c
FB
2567 AVInputFormat *ifmt;
2568 AVOutputFormat *ofmt;
817b23ff 2569 AVImageFormat *image_fmt;
85f07f22
FB
2570 URLProtocol *up;
2571 AVCodec *p;
2572 const char **pp;
2573
817b23ff 2574 printf("Output audio/video file formats:");
79fdaa4c
FB
2575 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
2576 printf(" %s", ofmt->name);
85f07f22
FB
2577 }
2578 printf("\n");
817b23ff
FB
2579
2580 printf("Input audio/video file formats:");
79fdaa4c
FB
2581 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
2582 printf(" %s", ifmt->name);
85f07f22
FB
2583 }
2584 printf("\n");
2585
817b23ff
FB
2586 printf("Output image formats:");
2587 for(image_fmt = first_image_format; image_fmt != NULL;
2588 image_fmt = image_fmt->next) {
2589 if (image_fmt->img_write)
2590 printf(" %s", image_fmt->name);
2591 }
2592 printf("\n");
2593
2594 printf("Input image formats:");
2595 for(image_fmt = first_image_format; image_fmt != NULL;
2596 image_fmt = image_fmt->next) {
2597 if (image_fmt->img_read)
2598 printf(" %s", image_fmt->name);
2599 }
2600 printf("\n");
2601
85f07f22
FB
2602 printf("Codecs:\n");
2603 printf(" Encoders:");
2604 for(p = first_avcodec; p != NULL; p = p->next) {
2605 if (p->encode)
2606 printf(" %s", p->name);
2607 }
2608 printf("\n");
2609
2610 printf(" Decoders:");
2611 for(p = first_avcodec; p != NULL; p = p->next) {
2612 if (p->decode)
2613 printf(" %s", p->name);
2614 }
2615 printf("\n");
2616
2617 printf("Supported file protocols:");
2618 for(up = first_protocol; up != NULL; up = up->next)
2619 printf(" %s:", up->name);
2620 printf("\n");
2621
2622 printf("Frame size abbreviations: sqcif qcif cif 4cif\n");
2623 printf("Motion estimation methods:");
2624 pp = motion_str;
2625 while (*pp) {
2626 printf(" %s", *pp);
101bea5f 2627 if ((pp - motion_str + 1) == ME_ZERO)
85f07f22 2628 printf("(fastest)");
101bea5f 2629 else if ((pp - motion_str + 1) == ME_FULL)
85f07f22 2630 printf("(slowest)");
101bea5f 2631 else if ((pp - motion_str + 1) == ME_EPZS)
85f07f22
FB
2632 printf("(default)");
2633 pp++;
2634 }
2635 printf("\n");
2636 exit(1);
2637}
2638
2639void show_help(void)
2640{
a38469e1 2641 const char *prog;
85f07f22
FB
2642 const OptionDef *po;
2643 int i, expert;
a38469e1
FB
2644
2645 prog = do_play ? "ffplay" : "ffmpeg";
85f07f22 2646
bf5af568 2647 printf("%s version " FFMPEG_VERSION ", Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n",
a38469e1
FB
2648 prog);
2649
2650 if (!do_play) {
2651 printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
2652 "Hyper fast MPEG1/MPEG4/H263/RV and AC3/MPEG audio encoder\n");
2653 } else {
2654 printf("usage: ffplay [options] input_file...\n"
2655 "Simple audio player\n");
2656 }
2657
2658 printf("\n"
85f07f22
FB
2659 "Main options are:\n");
2660 for(i=0;i<2;i++) {
2661 if (i == 1)
2662 printf("\nAdvanced options are:\n");
2663 for(po = options; po->name != NULL; po++) {
2664 char buf[64];
2665 expert = (po->flags & OPT_EXPERT) != 0;
2666 if (expert == i) {
2667 strcpy(buf, po->name);
2668 if (po->flags & HAS_ARG) {
2669 strcat(buf, " ");
2670 strcat(buf, po->argname);
2671 }
2672 printf("-%-17s %s\n", buf, po->help);
2673 }
2674 }
2675 }
2676
2677 exit(1);
2678}
2679
2680const OptionDef options[] = {
bdc4796f
FB
2681 { "L", 0, {(void*)show_licence}, "show license" },
2682 { "h", 0, {(void*)show_help}, "show help" },
2683 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
2684 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
817b23ff 2685 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
bdc4796f
FB
2686 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
2687 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
2688 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
2689 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
2690 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
2691 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
2692 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
2693 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
5abdb4b1
FB
2694 { "pass", HAS_ARG, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
2695 { "passlogfile", HAS_ARG | OPT_STRING, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
85f07f22 2696 /* video options */
bdc4796f
FB
2697 { "b", HAS_ARG, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
2698 { "r", HAS_ARG, {(void*)opt_frame_rate}, "set frame rate (in Hz)", "rate" },
e47ec515 2699 { "em_rate", OPT_BOOL|OPT_EXPERT, {(void*)&emulate_frame_rate}, "makes img reading happen at nominal frame rate" },
bdc4796f 2700 { "s", HAS_ARG, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
ab6d194a
MN
2701 { "croptop", HAS_ARG, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
2702 { "cropbottom", HAS_ARG, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
2703 { "cropleft", HAS_ARG, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
2704 { "cropright", HAS_ARG, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
bdc4796f
FB
2705 { "g", HAS_ARG | OPT_EXPERT, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
2706 { "intra", OPT_BOOL | OPT_EXPERT, {(void*)&intra_only}, "use only intra frames"},
2707 { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
2708 { "qscale", HAS_ARG | OPT_EXPERT, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
9cdd6a24
MN
2709 { "qmin", HAS_ARG | OPT_EXPERT, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
2710 { "qmax", HAS_ARG | OPT_EXPERT, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
17a70fde
MN
2711 { "mbqmin", HAS_ARG | OPT_EXPERT, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
2712 { "mbqmax", HAS_ARG | OPT_EXPERT, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
9cdd6a24
MN
2713 { "qdiff", HAS_ARG | OPT_EXPERT, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
2714 { "qblur", HAS_ARG | OPT_EXPERT, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
2715 { "qcomp", HAS_ARG | OPT_EXPERT, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
ac2830ec 2716 { "rc_init_cplx", HAS_ARG | OPT_EXPERT, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
29700fa6
MN
2717 { "b_qfactor", HAS_ARG | OPT_EXPERT, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
2718 { "i_qfactor", HAS_ARG | OPT_EXPERT, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
2719 { "b_qoffset", HAS_ARG | OPT_EXPERT, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
2720 { "i_qoffset", HAS_ARG | OPT_EXPERT, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
59b571c1 2721// { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3aa102be 2722 { "rc_eq", HAS_ARG | OPT_EXPERT, {(void*)opt_video_rc_eq}, "", "equation" },
ac2830ec 2723 { "rc_override", HAS_ARG | OPT_EXPERT, {(void*)opt_video_rc_override_string}, "Rate control override", "qualities for specific intervals" },
9cdd6a24 2724 { "bt", HAS_ARG, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3aa102be
MN
2725 { "maxrate", HAS_ARG, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
2726 { "minrate", HAS_ARG, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
946c8a12 2727 { "bufsize", HAS_ARG, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kbit)", "size" },
bf5af568 2728 { "vd", HAS_ARG | OPT_EXPERT, {(void*)opt_video_device}, "set video grab device", "device" },
a5df11ab 2729 { "vc", HAS_ARG | OPT_EXPERT, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
79a7c268 2730 { "dv1394", OPT_EXPERT, {(void*)opt_dv1394}, "set DV1394 grab", "" },
1629626f 2731 { "vcodec", HAS_ARG | OPT_EXPERT, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
bdc4796f 2732 { "me", HAS_ARG | OPT_EXPERT, {(void*)opt_motion_estimation}, "set motion estimation method",
85f07f22 2733 "method" },
463678ac 2734 { "dct_algo", HAS_ARG | OPT_EXPERT, {(void*)opt_dct_algo}, "set dct algo", "algo" },
2ad1516a 2735 { "idct_algo", HAS_ARG | OPT_EXPERT, {(void*)opt_idct_algo}, "set idct algo", "algo" },
8409b8fe 2736 { "er", HAS_ARG | OPT_EXPERT, {(void*)opt_error_resilience}, "set error resilience", "" },
59b571c1 2737 { "ec", HAS_ARG | OPT_EXPERT, {(void*)opt_error_concealment}, "set error concealment", "" },
bc6caae2 2738 { "bf", HAS_ARG | OPT_EXPERT, {(void*)opt_b_frames}, "use 'frames' B frames (only MPEG-4)", "frames" },
e4986da9 2739 { "hq", OPT_BOOL | OPT_EXPERT, {(void*)&use_hq}, "activate high quality settings" },
29da453b 2740 { "4mv", OPT_BOOL | OPT_EXPERT, {(void*)&use_4mv}, "use four motion vector by macroblock (only MPEG-4)" },
1dbb6d90 2741 { "part", OPT_BOOL | OPT_EXPERT, {(void*)&use_part}, "use data partitioning (only MPEG-4)" },
fe670d09 2742 { "bug", HAS_ARG | OPT_EXPERT, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
1dbb6d90 2743 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "packet size", "size in bits" },
f560dd82 2744 { "strict", HAS_ARG | OPT_EXPERT, {(void*)opt_strict}, "strictness", "how strictly to follow the standarts" },
bdc4796f 2745 { "sameq", OPT_BOOL, {(void*)&same_quality},
85f07f22 2746 "use same video quality as source (implies VBR)" },
1d366fce 2747 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
85f07f22 2748 /* audio options */
bdc4796f
FB
2749 { "ab", HAS_ARG, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
2750 { "ar", HAS_ARG, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
2751 { "ac", HAS_ARG, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
2752 { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
bdc4796f 2753 { "ad", HAS_ARG | OPT_EXPERT, {(void*)opt_audio_device}, "set audio device", "device" },
1629626f 2754 { "acodec", HAS_ARG | OPT_EXPERT, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
bdc4796f 2755 { "deinterlace", OPT_BOOL | OPT_EXPERT, {(void*)&do_deinterlace},
cfcf0ffd 2756 "deinterlace pictures" },
bdc4796f 2757 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5727b222 2758 "add timings for benchmarking" },
a0663ba4
FB
2759 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
2760 "dump each input packet" },
ce7c56c2
J
2761 { "psnr", OPT_BOOL | OPT_EXPERT, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
2762 { "vstats", OPT_BOOL | OPT_EXPERT, {(void*)&do_vstats}, "dump video coding statistics to file" },
79fdaa4c 2763 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
10d104e4 2764 { "vhook", HAS_ARG | OPT_EXPERT, {(void*)add_frame_hooker}, "insert video processing module", "module name and parameters" },
85f07f22
FB
2765 { NULL, },
2766};
2767
2768int main(int argc, char **argv)
2769{
2770 int optindex, i;
2771 const char *opt, *arg;
2772 const OptionDef *po;
a38469e1 2773 INT64 ti;
63b15e55 2774
2c4ae653 2775 av_register_all();
85f07f22 2776
a38469e1
FB
2777 /* detect if invoked as player */
2778 i = strlen(argv[0]);
2779 if (i >= 6 && !strcmp(argv[0] + i - 6, "ffplay"))
2780 do_play = 1;
2781
85f07f22
FB
2782 if (argc <= 1)
2783 show_help();
a38469e1
FB
2784
2785 /* parse options */
85f07f22
FB
2786 optindex = 1;
2787 while (optindex < argc) {
2788 opt = argv[optindex++];
2789
2790 if (opt[0] == '-' && opt[1] != '\0') {
2791 po = options;
2792 while (po->name != NULL) {
2793 if (!strcmp(opt + 1, po->name))
2794 break;
2795 po++;
2796 }
2797 if (!po->name) {
2798 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
2799 exit(1);
2800 }
2801 arg = NULL;
10d104e4 2802 if (po->flags & HAS_ARG) {
85f07f22 2803 arg = argv[optindex++];
10d104e4
PG
2804 if (!arg) {
2805 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
2806 exit(1);
2807 }
2808 }
85f07f22
FB
2809 if (po->flags & OPT_STRING) {
2810 char *str;
e9a9e0c2 2811 str = av_strdup(arg);
85f07f22
FB
2812 *po->u.str_arg = str;
2813 } else if (po->flags & OPT_BOOL) {
2814 *po->u.int_arg = 1;
2815 } else {
2816 po->u.func_arg(arg);
2817 }
2818 } else {
a38469e1
FB
2819 if (!do_play) {
2820 opt_output_file(opt);
2821 } else {
2822 opt_input_file(opt);
2823 }
85f07f22
FB
2824 }
2825 }
2826
2827
a38469e1
FB
2828 if (!do_play) {
2829 /* file converter / grab */
85f07f22
FB
2830 if (nb_output_files <= 0) {
2831 fprintf(stderr, "Must supply at least one output file\n");
2832 exit(1);
2833 }
a38469e1
FB
2834
2835 if (nb_input_files == 0) {
2836 prepare_grab();
5727b222 2837 }
a38469e1
FB
2838 } else {
2839 /* player */
2840 if (nb_input_files <= 0) {
2841 fprintf(stderr, "Must supply at least one input file\n");
2842 exit(1);
2843 }
2844 prepare_play();
2845 }
2846
2847 ti = getutime();
2848 av_encode(output_files, nb_output_files, input_files, nb_input_files,
2849 stream_maps, nb_stream_maps);
2850 ti = getutime() - ti;
2851 if (do_benchmark) {
2852 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
85f07f22
FB
2853 }
2854
2855 /* close files */
2856 for(i=0;i<nb_output_files;i++) {
4fca59f2
ZK
2857 /* maybe av_close_output_file ??? */
2858 AVFormatContext *s = output_files[i];
2859 int j;
2860 if (!(s->oformat->flags & AVFMT_NOFILE))
2861 url_fclose(&s->pb);
2862 for(j=0;j<s->nb_streams;j++)
2863 av_free(s->streams[j]);
2864 av_free(s);
85f07f22 2865 }
79fdaa4c
FB
2866 for(i=0;i<nb_input_files;i++)
2867 av_close_input_file(input_files[i]);
85f07f22 2868
855ea723 2869 av_free_static();
db40a39a
MN
2870
2871
35e5fb06
RD
2872#ifdef POWERPC_TBL_PERFORMANCE_REPORT
2873 extern void powerpc_display_perf_report(void);
2874 powerpc_display_perf_report();
2875#endif /* POWERPC_TBL_PERFORMANCE_REPORT */
db40a39a 2876
85f07f22
FB
2877 return 0;
2878}