video_device fixes
[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
MK
161static char *video_grab_format = "video4linux";
162static char *audio_grab_format = "audio_device";
163
5abdb4b1 164#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
85f07f22 165
dfdfa47c 166#if !defined(CONFIG_AUDIO_OSS) && !defined(CONFIG_AUDIO_BEOS)
bf5af568
FB
167const char *audio_device = "none";
168#endif
bf5af568 169
85f07f22
FB
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{
8aa3ee32 1873 video_device = strdup(arg);
85f07f22
FB
1874}
1875
1876void opt_audio_device(const char *arg)
1877{
1878 audio_device = strdup(arg);
1879}
1880
8aa3ee32
MK
1881void opt_dv1394(const char *arg)
1882{
1883 video_grab_format = "dv1394";
1884 audio_grab_format = "none";
1885}
1886
85f07f22
FB
1887void opt_audio_codec(const char *arg)
1888{
1889 AVCodec *p;
1890
1629626f
FB
1891 if (!strcmp(arg, "copy")) {
1892 audio_stream_copy = 1;
85f07f22 1893 } else {
1629626f
FB
1894 p = first_avcodec;
1895 while (p) {
1896 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
1897 break;
1898 p = p->next;
1899 }
1900 if (p == NULL) {
1901 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
1902 exit(1);
1903 } else {
1904 audio_codec_id = p->id;
1905 }
85f07f22
FB
1906 }
1907}
1908
10d104e4
PG
1909void add_frame_hooker(const char *arg)
1910{
1911 int argc = 0;
1912 char *argv[64];
1913 int i;
1914 char *args = strdup(arg);
1915
1916 argv[0] = strtok(args, " ");
1917 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
1918 }
1919
1920 i = frame_hook_add(argc, argv);
1921
1922 if (i != 0) {
1923 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
1924 exit(1);
1925 }
1926}
1927
85f07f22
FB
1928const char *motion_str[] = {
1929 "zero",
1930 "full",
1931 "log",
1932 "phods",
7084c149
MN
1933 "epzs",
1934 "x1",
85f07f22
FB
1935 NULL,
1936};
1937
1938void opt_motion_estimation(const char *arg)
1939{
1940 const char **p;
1941 p = motion_str;
1942 for(;;) {
1943 if (!*p) {
1944 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
1945 exit(1);
1946 }
1947 if (!strcmp(*p, arg))
1948 break;
1949 p++;
1950 }
101bea5f 1951 me_method = (p - motion_str) + 1;
85f07f22
FB
1952}
1953
1954void opt_video_codec(const char *arg)
1955{
1956 AVCodec *p;
1957
1629626f
FB
1958 if (!strcmp(arg, "copy")) {
1959 video_stream_copy = 1;
85f07f22 1960 } else {
1629626f
FB
1961 p = first_avcodec;
1962 while (p) {
1963 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
1964 break;
1965 p = p->next;
1966 }
1967 if (p == NULL) {
1968 fprintf(stderr, "Unknown video codec '%s'\n", arg);
1969 exit(1);
1970 } else {
1971 video_codec_id = p->id;
1972 }
85f07f22
FB
1973 }
1974}
1975
1976void opt_map(const char *arg)
1977{
1978 AVStreamMap *m;
1979 const char *p;
1980
1981 p = arg;
1982 m = &stream_maps[nb_stream_maps++];
1983
1984 m->file_index = strtol(arg, (char **)&p, 0);
1985 if (*p)
1986 p++;
a5dc85ef
J
1987
1988 m->stream_index = strtol(p, (char **)&p, 0);
85f07f22
FB
1989}
1990
1991void opt_recording_time(const char *arg)
1992{
1993 recording_time = parse_date(arg, 1);
1994}
1995
79fdaa4c 1996void print_error(const char *filename, int err)
919f448d 1997{
79fdaa4c
FB
1998 switch(err) {
1999 case AVERROR_NUMEXPECTED:
919f448d
FB
2000 fprintf(stderr, "%s: Incorrect image filename syntax.\n"
2001 "Use '%%d' to specify the image number:\n"
2002 " for img1.jpg, img2.jpg, ..., use 'img%%d.jpg';\n"
2003 " for img001.jpg, img002.jpg, ..., use 'img%%03d.jpg'.\n",
2004 filename);
79fdaa4c
FB
2005 break;
2006 case AVERROR_INVALIDDATA:
2007 fprintf(stderr, "%s: Error while parsing header\n", filename);
2008 break;
2009 case AVERROR_NOFMT:
2010 fprintf(stderr, "%s: Unknown format\n", filename);
2011 break;
2012 default:
2013 fprintf(stderr, "%s: Error while opening file\n", filename);
2014 break;
919f448d
FB
2015 }
2016}
85f07f22
FB
2017
2018void opt_input_file(const char *filename)
2019{
2020 AVFormatContext *ic;
2021 AVFormatParameters params, *ap = &params;
6dc96cb0 2022 int err, i, ret, rfps;
85f07f22 2023
b242baa4
FB
2024 if (!strcmp(filename, "-"))
2025 filename = "pipe:";
2026
85f07f22 2027 /* get default parameters from command line */
79fdaa4c
FB
2028 memset(ap, 0, sizeof(*ap));
2029 ap->sample_rate = audio_sample_rate;
2030 ap->channels = audio_channels;
2031 ap->frame_rate = frame_rate;
2032 ap->width = frame_width;
2033 ap->height = frame_height;
817b23ff 2034 ap->image_format = image_format;
79fdaa4c
FB
2035
2036 /* open the input file with generic libav function */
2037 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
85f07f22 2038 if (err < 0) {
79fdaa4c 2039 print_error(filename, err);
85f07f22
FB
2040 exit(1);
2041 }
2042
79fdaa4c
FB
2043 /* If not enough info to get the stream parameters, we decode the
2044 first frames to get it. (used in mpeg case for example) */
2045 ret = av_find_stream_info(ic);
85f07f22
FB
2046 if (ret < 0) {
2047 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2048 exit(1);
2049 }
2050
2051 /* update the current parameters so that they match the one of the input stream */
2052 for(i=0;i<ic->nb_streams;i++) {
2053 AVCodecContext *enc = &ic->streams[i]->codec;
2054 switch(enc->codec_type) {
2055 case CODEC_TYPE_AUDIO:
e0d2714a 2056 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
85f07f22
FB
2057 audio_channels = enc->channels;
2058 audio_sample_rate = enc->sample_rate;
2059 break;
2060 case CODEC_TYPE_VIDEO:
2061 frame_height = enc->height;
2062 frame_width = enc->width;
79fdaa4c 2063 rfps = ic->streams[i]->r_frame_rate;
fe670d09 2064 enc->workaround_bugs = workaround_bugs;
8409b8fe 2065 enc->error_resilience = error_resilience;
4d2858de 2066 enc->error_concealment = error_concealment;
2ad1516a 2067 enc->idct_algo= idct_algo;
59b571c1 2068 enc->debug= debug;
d7425f59
MN
2069/* if(enc->codec->capabilities & CODEC_CAP_TRUNCATED)
2070 enc->flags|= CODEC_FLAG_TRUNCATED; */
2071 if(/*enc->codec_id==CODEC_ID_MPEG4 || */enc->codec_id==CODEC_ID_MPEG1VIDEO)
2072 enc->flags|= CODEC_FLAG_TRUNCATED;
2073
79fdaa4c 2074 if (enc->frame_rate != rfps) {
6dc96cb0
J
2075 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2076 i, (float)enc->frame_rate / FRAME_RATE_BASE,
2077 (float)rfps / FRAME_RATE_BASE);
79fdaa4c 2078 }
bf5af568
FB
2079 /* update the current frame rate to match the stream frame rate */
2080 frame_rate = rfps;
85f07f22 2081 break;
51bd4565 2082 default:
c04643a2 2083 av_abort();
85f07f22
FB
2084 }
2085 }
2086
2087 input_files[nb_input_files] = ic;
2088 /* dump the file content */
2089 dump_format(ic, nb_input_files, filename, 0);
2090 nb_input_files++;
79fdaa4c
FB
2091 file_iformat = NULL;
2092 file_oformat = NULL;
817b23ff 2093 image_format = NULL;
85f07f22
FB
2094}
2095
919f448d
FB
2096void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2097{
2098 int has_video, has_audio, i, j;
2099 AVFormatContext *ic;
2100
2101 has_video = 0;
2102 has_audio = 0;
2103 for(j=0;j<nb_input_files;j++) {
2104 ic = input_files[j];
2105 for(i=0;i<ic->nb_streams;i++) {
2106 AVCodecContext *enc = &ic->streams[i]->codec;
2107 switch(enc->codec_type) {
2108 case CODEC_TYPE_AUDIO:
2109 has_audio = 1;
2110 break;
2111 case CODEC_TYPE_VIDEO:
2112 has_video = 1;
2113 break;
51bd4565 2114 default:
c04643a2 2115 av_abort();
919f448d
FB
2116 }
2117 }
2118 }
2119 *has_video_ptr = has_video;
2120 *has_audio_ptr = has_audio;
2121}
2122
85f07f22
FB
2123void opt_output_file(const char *filename)
2124{
2125 AVStream *st;
2126 AVFormatContext *oc;
919f448d 2127 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
85f07f22 2128 int codec_id;
817b23ff 2129 AVFormatParameters params, *ap = &params;
85f07f22
FB
2130
2131 if (!strcmp(filename, "-"))
2132 filename = "pipe:";
2133
2134 oc = av_mallocz(sizeof(AVFormatContext));
2135
79fdaa4c
FB
2136 if (!file_oformat) {
2137 file_oformat = guess_format(NULL, filename, NULL);
2138 if (!file_oformat) {
2139 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2140 filename);
2141 exit(1);
2142 }
85f07f22
FB
2143 }
2144
79fdaa4c 2145 oc->oformat = file_oformat;
85f07f22 2146
79fdaa4c 2147 if (!strcmp(file_oformat->name, "ffm") &&
85f07f22
FB
2148 strstart(filename, "http:", NULL)) {
2149 /* special case for files sent to ffserver: we get the stream
2150 parameters from ffserver */
2151 if (read_ffserver_streams(oc, filename) < 0) {
2152 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2153 exit(1);
2154 }
2155 } else {
79fdaa4c
FB
2156 use_video = file_oformat->video_codec != CODEC_ID_NONE;
2157 use_audio = file_oformat->audio_codec != CODEC_ID_NONE;
919f448d 2158
e30a2846
FB
2159 /* disable if no corresponding type found and at least one
2160 input file */
2161 if (nb_input_files > 0) {
2162 check_audio_video_inputs(&input_has_video, &input_has_audio);
2163 if (!input_has_video)
2164 use_video = 0;
2165 if (!input_has_audio)
2166 use_audio = 0;
2167 }
919f448d
FB
2168
2169 /* manual disable */
85f07f22
FB
2170 if (audio_disable) {
2171 use_audio = 0;
2172 }
2173 if (video_disable) {
2174 use_video = 0;
2175 }
2176
2177 nb_streams = 0;
2178 if (use_video) {
2179 AVCodecContext *video_enc;
2180
2181 st = av_mallocz(sizeof(AVStream));
2182 if (!st) {
2183 fprintf(stderr, "Could not alloc stream\n");
2184 exit(1);
2185 }
1e491e29 2186 avcodec_get_context_defaults(&st->codec);
85f07f22 2187
1629626f
FB
2188 video_enc = &st->codec;
2189 if (video_stream_copy) {
2190 st->stream_copy = 1;
2191 video_enc->codec_type = CODEC_TYPE_VIDEO;
2192 } else {
ac2830ec
MN
2193 char *p;
2194 int i;
2195
1629626f
FB
2196 codec_id = file_oformat->video_codec;
2197 if (video_codec_id != CODEC_ID_NONE)
2198 codec_id = video_codec_id;
2199
2200 video_enc->codec_id = codec_id;
2201
2202 video_enc->bit_rate = video_bit_rate;
2203 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2204 video_enc->frame_rate = frame_rate;
2205
2206 video_enc->width = frame_width;
2207 video_enc->height = frame_height;
2208
2209 if (!intra_only)
2210 video_enc->gop_size = gop_size;
2211 else
2212 video_enc->gop_size = 0;
2213 if (video_qscale || same_quality) {
2214 video_enc->flags |= CODEC_FLAG_QSCALE;
1e491e29 2215 st->quality = video_qscale;
1629626f 2216 }
9cdd6a24 2217
1629626f
FB
2218 if (use_hq) {
2219 video_enc->flags |= CODEC_FLAG_HQ;
2220 }
e4986da9 2221
1629626f
FB
2222 if (use_4mv) {
2223 video_enc->flags |= CODEC_FLAG_HQ;
2224 video_enc->flags |= CODEC_FLAG_4MV;
2225 }
bc6caae2 2226
1629626f
FB
2227 if(use_part)
2228 video_enc->flags |= CODEC_FLAG_PART;
1dbb6d90
MN
2229
2230
1629626f
FB
2231 if (b_frames) {
2232 if (codec_id != CODEC_ID_MPEG4) {
2233 fprintf(stderr, "\nB frames encoding only supported by MPEG-4.\n");
2234 exit(1);
2235 }
2236 video_enc->max_b_frames = b_frames;
2237 video_enc->b_frame_strategy = 0;
2238 video_enc->b_quant_factor = 2.0;
bc6caae2 2239 }
bc6caae2 2240
1629626f
FB
2241 video_enc->qmin = video_qmin;
2242 video_enc->qmax = video_qmax;
17a70fde
MN
2243 video_enc->mb_qmin = video_mb_qmin;
2244 video_enc->mb_qmax = video_mb_qmax;
1629626f
FB
2245 video_enc->max_qdiff = video_qdiff;
2246 video_enc->qblur = video_qblur;
2247 video_enc->qcompress = video_qcomp;
2248 video_enc->rc_eq = video_rc_eq;
59b571c1 2249 video_enc->debug= debug;
ac2830ec
MN
2250
2251 p= video_rc_override_string;
2252 for(i=0; p; i++){
2253 int start, end, q;
2254 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2255 if(e!=3){
2256 fprintf(stderr, "error parsing rc_override\n");
2257 exit(1);
2258 }
2259 video_enc->rc_override=
2260 realloc(video_enc->rc_override, sizeof(RcOverride)*(i+1));
2261 video_enc->rc_override[i].start_frame= start;
2262 video_enc->rc_override[i].end_frame = end;
2263 if(q>0){
2264 video_enc->rc_override[i].qscale= q;
2265 video_enc->rc_override[i].quality_factor= 1.0;
2266 }
2267 else{
2268 video_enc->rc_override[i].qscale= 0;
2269 video_enc->rc_override[i].quality_factor= -q/100.0;
2270 }
2271 p= strchr(p, '/');
2272 if(p) p++;
2273 }
2274 video_enc->rc_override_count=i;
2275
1629626f
FB
2276 video_enc->rc_max_rate = video_rc_max_rate;
2277 video_enc->rc_min_rate = video_rc_min_rate;
2278 video_enc->rc_buffer_size = video_rc_buffer_size;
2279 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
ac2830ec 2280 video_enc->rc_initial_cplx= video_rc_initial_cplx;
1629626f
FB
2281 video_enc->i_quant_factor = video_i_qfactor;
2282 video_enc->b_quant_factor = video_b_qfactor;
2283 video_enc->i_quant_offset = video_i_qoffset;
2284 video_enc->b_quant_offset = video_b_qoffset;
2285 video_enc->dct_algo = dct_algo;
2286 video_enc->idct_algo = idct_algo;
f560dd82 2287 video_enc->strict_std_compliance = strict;
1629626f
FB
2288 if(packet_size){
2289 video_enc->rtp_mode= 1;
2290 video_enc->rtp_payload_size= packet_size;
2291 }
9cdd6a24 2292
1629626f 2293 if (do_psnr)
140cb663 2294 video_enc->flags|= CODEC_FLAG_PSNR;
e4986da9 2295
1629626f 2296 video_enc->me_method = me_method;
5abdb4b1 2297
1629626f
FB
2298 /* two pass mode */
2299 if (do_pass) {
2300 if (do_pass == 1) {
2301 video_enc->flags |= CODEC_FLAG_PASS1;
2302 } else {
2303 video_enc->flags |= CODEC_FLAG_PASS2;
2304 }
5abdb4b1 2305 }
cfcf0ffd 2306 }
85f07f22
FB
2307 oc->streams[nb_streams] = st;
2308 nb_streams++;
2309 }
2310
2311 if (use_audio) {
2312 AVCodecContext *audio_enc;
2313
2314 st = av_mallocz(sizeof(AVStream));
2315 if (!st) {
2316 fprintf(stderr, "Could not alloc stream\n");
2317 exit(1);
2318 }
1e491e29 2319 avcodec_get_context_defaults(&st->codec);
1629626f 2320
85f07f22 2321 audio_enc = &st->codec;
85f07f22 2322 audio_enc->codec_type = CODEC_TYPE_AUDIO;
1629626f
FB
2323 if (audio_stream_copy) {
2324 st->stream_copy = 1;
2325 } else {
2326 codec_id = file_oformat->audio_codec;
2327 if (audio_codec_id != CODEC_ID_NONE)
2328 codec_id = audio_codec_id;
2329 audio_enc->codec_id = codec_id;
2330
2331 audio_enc->bit_rate = audio_bit_rate;
2332 audio_enc->sample_rate = audio_sample_rate;
2333 /* For audio codecs other than AC3 we limit */
2334 /* the number of coded channels to stereo */
2335 if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
2336 audio_enc->channels = 2;
2337 } else
2338 audio_enc->channels = audio_channels;
2339 }
85f07f22
FB
2340 oc->streams[nb_streams] = st;
2341 nb_streams++;
2342 }
2343
2344 oc->nb_streams = nb_streams;
2345
2346 if (!nb_streams) {
919f448d 2347 fprintf(stderr, "No audio or video streams available\n");
85f07f22
FB
2348 exit(1);
2349 }
2350
2351 if (str_title)
79fdaa4c 2352 pstrcpy(oc->title, sizeof(oc->title), str_title);
85f07f22 2353 if (str_author)
79fdaa4c 2354 pstrcpy(oc->author, sizeof(oc->author), str_author);
85f07f22 2355 if (str_copyright)
79fdaa4c 2356 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
85f07f22 2357 if (str_comment)
79fdaa4c 2358 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
85f07f22
FB
2359 }
2360
1629626f 2361 output_files[nb_output_files++] = oc;
85f07f22
FB
2362
2363 strcpy(oc->filename, filename);
919f448d
FB
2364
2365 /* check filename in case of an image number is expected */
79fdaa4c
FB
2366 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2367 if (filename_number_test(oc->filename) < 0) {
2368 print_error(oc->filename, AVERROR_NUMEXPECTED);
919f448d 2369 exit(1);
79fdaa4c 2370 }
919f448d
FB
2371 }
2372
79fdaa4c 2373 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
85f07f22
FB
2374 /* test if it already exists to avoid loosing precious files */
2375 if (!file_overwrite &&
2376 (strchr(filename, ':') == NULL ||
2377 strstart(filename, "file:", NULL))) {
2378 if (url_exist(filename)) {
2379 int c;
2380
2381 printf("File '%s' already exists. Overwrite ? [y/N] ", filename);
2382 fflush(stdout);
2383 c = getchar();
2384 if (toupper(c) != 'Y') {
2385 fprintf(stderr, "Not overwriting - exiting\n");
2386 exit(1);
2387 }
2388 }
2389 }
2390
2391 /* open the file */
2392 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
2393 fprintf(stderr, "Could not open '%s'\n", filename);
2394 exit(1);
2395 }
2396 }
2397
817b23ff
FB
2398 memset(ap, 0, sizeof(*ap));
2399 ap->image_format = image_format;
2400 if (av_set_parameters(oc, ap) < 0) {
2401 fprintf(stderr, "%s: Invalid encoding parameters\n",
2402 oc->filename);
2403 exit(1);
2404 }
2405
85f07f22 2406 /* reset some options */
79fdaa4c
FB
2407 file_oformat = NULL;
2408 file_iformat = NULL;
817b23ff 2409 image_format = NULL;
85f07f22
FB
2410 audio_disable = 0;
2411 video_disable = 0;
2412 audio_codec_id = CODEC_ID_NONE;
2413 video_codec_id = CODEC_ID_NONE;
1629626f
FB
2414 audio_stream_copy = 0;
2415 video_stream_copy = 0;
85f07f22
FB
2416}
2417
a38469e1
FB
2418/* prepare dummy protocols for grab */
2419void prepare_grab(void)
2420{
2421 int has_video, has_audio, i, j;
2422 AVFormatContext *oc;
2423 AVFormatContext *ic;
2424 AVFormatParameters ap1, *ap = &ap1;
2425
2426 /* see if audio/video inputs are needed */
2427 has_video = 0;
2428 has_audio = 0;
2429 memset(ap, 0, sizeof(*ap));
2430 for(j=0;j<nb_output_files;j++) {
2431 oc = output_files[j];
2432 for(i=0;i<oc->nb_streams;i++) {
2433 AVCodecContext *enc = &oc->streams[i]->codec;
2434 switch(enc->codec_type) {
2435 case CODEC_TYPE_AUDIO:
2436 if (enc->sample_rate > ap->sample_rate)
2437 ap->sample_rate = enc->sample_rate;
2438 if (enc->channels > ap->channels)
2439 ap->channels = enc->channels;
2440 has_audio = 1;
2441 break;
2442 case CODEC_TYPE_VIDEO:
2443 if (enc->width > ap->width)
2444 ap->width = enc->width;
2445 if (enc->height > ap->height)
2446 ap->height = enc->height;
2447 if (enc->frame_rate > ap->frame_rate)
2448 ap->frame_rate = enc->frame_rate;
2449 has_video = 1;
2450 break;
51bd4565 2451 default:
c04643a2 2452 av_abort();
a38469e1
FB
2453 }
2454 }
2455 }
2456
2457 if (has_video == 0 && has_audio == 0) {
2458 fprintf(stderr, "Output file must have at least one audio or video stream\n");
2459 exit(1);
2460 }
2461
2462 if (has_video) {
79fdaa4c 2463 AVInputFormat *fmt1;
8aa3ee32 2464 fmt1 = av_find_input_format(video_grab_format);
79fdaa4c 2465 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
bf5af568 2466 fprintf(stderr, "Could not find video grab device\n");
a38469e1
FB
2467 exit(1);
2468 }
79fdaa4c
FB
2469 /* by now video grab has one stream */
2470 ic->streams[0]->r_frame_rate = ap->frame_rate;
a38469e1 2471 input_files[nb_input_files] = ic;
8aa3ee32 2472 dump_format(ic, nb_input_files, video_device, 0);
a38469e1
FB
2473 nb_input_files++;
2474 }
2475 if (has_audio) {
79fdaa4c 2476 AVInputFormat *fmt1;
8aa3ee32 2477 fmt1 = av_find_input_format(audio_grab_format);
79fdaa4c 2478 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
bf5af568 2479 fprintf(stderr, "Could not find audio grab device\n");
a38469e1
FB
2480 exit(1);
2481 }
2482 input_files[nb_input_files] = ic;
2483 dump_format(ic, nb_input_files, audio_device, 0);
2484 nb_input_files++;
2485 }
2486}
2487
a38469e1
FB
2488/* open the necessary output devices for playing */
2489void prepare_play(void)
2490{
bf5af568
FB
2491 file_iformat = NULL;
2492 file_oformat = guess_format("audio_device", NULL, NULL);
2493 if (!file_oformat) {
a38469e1
FB
2494 fprintf(stderr, "Could not find audio device\n");
2495 exit(1);
2496 }
2497
2498 opt_output_file(audio_device);
2499}
2500
5abdb4b1
FB
2501/* same option as mencoder */
2502void opt_pass(const char *pass_str)
2503{
2504 int pass;
2505 pass = atoi(pass_str);
2506 if (pass != 1 && pass != 2) {
2507 fprintf(stderr, "pass number can be only 1 or 2\n");
2508 exit(1);
2509 }
2510 do_pass = pass;
2511}
a38469e1 2512
f3ec2d46 2513#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
5727b222
FB
2514INT64 getutime(void)
2515{
f3ec2d46 2516 return av_gettime();
5727b222 2517}
bdc4796f
FB
2518#else
2519INT64 getutime(void)
2520{
f3ec2d46
SG
2521 struct rusage rusage;
2522
2523 getrusage(RUSAGE_SELF, &rusage);
2524 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
bdc4796f
FB
2525}
2526#endif
5727b222 2527
79fdaa4c
FB
2528extern int ffm_nopts;
2529
2530void opt_bitexact(void)
2531{
2532 avcodec_set_bit_exact();
2533 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2534 ffm_nopts = 1;
2535}
2536
85f07f22
FB
2537void show_formats(void)
2538{
79fdaa4c
FB
2539 AVInputFormat *ifmt;
2540 AVOutputFormat *ofmt;
817b23ff 2541 AVImageFormat *image_fmt;
85f07f22
FB
2542 URLProtocol *up;
2543 AVCodec *p;
2544 const char **pp;
2545
817b23ff 2546 printf("Output audio/video file formats:");
79fdaa4c
FB
2547 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
2548 printf(" %s", ofmt->name);
85f07f22
FB
2549 }
2550 printf("\n");
817b23ff
FB
2551
2552 printf("Input audio/video file formats:");
79fdaa4c
FB
2553 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
2554 printf(" %s", ifmt->name);
85f07f22
FB
2555 }
2556 printf("\n");
2557
817b23ff
FB
2558 printf("Output image formats:");
2559 for(image_fmt = first_image_format; image_fmt != NULL;
2560 image_fmt = image_fmt->next) {
2561 if (image_fmt->img_write)
2562 printf(" %s", image_fmt->name);
2563 }
2564 printf("\n");
2565
2566 printf("Input image formats:");
2567 for(image_fmt = first_image_format; image_fmt != NULL;
2568 image_fmt = image_fmt->next) {
2569 if (image_fmt->img_read)
2570 printf(" %s", image_fmt->name);
2571 }
2572 printf("\n");
2573
85f07f22
FB
2574 printf("Codecs:\n");
2575 printf(" Encoders:");
2576 for(p = first_avcodec; p != NULL; p = p->next) {
2577 if (p->encode)
2578 printf(" %s", p->name);
2579 }
2580 printf("\n");
2581
2582 printf(" Decoders:");
2583 for(p = first_avcodec; p != NULL; p = p->next) {
2584 if (p->decode)
2585 printf(" %s", p->name);
2586 }
2587 printf("\n");
2588
2589 printf("Supported file protocols:");
2590 for(up = first_protocol; up != NULL; up = up->next)
2591 printf(" %s:", up->name);
2592 printf("\n");
2593
2594 printf("Frame size abbreviations: sqcif qcif cif 4cif\n");
2595 printf("Motion estimation methods:");
2596 pp = motion_str;
2597 while (*pp) {
2598 printf(" %s", *pp);
101bea5f 2599 if ((pp - motion_str + 1) == ME_ZERO)
85f07f22 2600 printf("(fastest)");
101bea5f 2601 else if ((pp - motion_str + 1) == ME_FULL)
85f07f22 2602 printf("(slowest)");
101bea5f 2603 else if ((pp - motion_str + 1) == ME_EPZS)
85f07f22
FB
2604 printf("(default)");
2605 pp++;
2606 }
2607 printf("\n");
2608 exit(1);
2609}
2610
2611void show_help(void)
2612{
a38469e1 2613 const char *prog;
85f07f22
FB
2614 const OptionDef *po;
2615 int i, expert;
a38469e1
FB
2616
2617 prog = do_play ? "ffplay" : "ffmpeg";
85f07f22 2618
bf5af568 2619 printf("%s version " FFMPEG_VERSION ", Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n",
a38469e1
FB
2620 prog);
2621
2622 if (!do_play) {
2623 printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
2624 "Hyper fast MPEG1/MPEG4/H263/RV and AC3/MPEG audio encoder\n");
2625 } else {
2626 printf("usage: ffplay [options] input_file...\n"
2627 "Simple audio player\n");
2628 }
2629
2630 printf("\n"
85f07f22
FB
2631 "Main options are:\n");
2632 for(i=0;i<2;i++) {
2633 if (i == 1)
2634 printf("\nAdvanced options are:\n");
2635 for(po = options; po->name != NULL; po++) {
2636 char buf[64];
2637 expert = (po->flags & OPT_EXPERT) != 0;
2638 if (expert == i) {
2639 strcpy(buf, po->name);
2640 if (po->flags & HAS_ARG) {
2641 strcat(buf, " ");
2642 strcat(buf, po->argname);
2643 }
2644 printf("-%-17s %s\n", buf, po->help);
2645 }
2646 }
2647 }
2648
2649 exit(1);
2650}
2651
2652const OptionDef options[] = {
bdc4796f
FB
2653 { "L", 0, {(void*)show_licence}, "show license" },
2654 { "h", 0, {(void*)show_help}, "show help" },
2655 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
2656 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
817b23ff 2657 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
bdc4796f
FB
2658 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
2659 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
2660 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
2661 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
2662 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
2663 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
2664 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
2665 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
5abdb4b1
FB
2666 { "pass", HAS_ARG, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
2667 { "passlogfile", HAS_ARG | OPT_STRING, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
85f07f22 2668 /* video options */
bdc4796f
FB
2669 { "b", HAS_ARG, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
2670 { "r", HAS_ARG, {(void*)opt_frame_rate}, "set frame rate (in Hz)", "rate" },
e47ec515 2671 { "em_rate", OPT_BOOL|OPT_EXPERT, {(void*)&emulate_frame_rate}, "makes img reading happen at nominal frame rate" },
bdc4796f 2672 { "s", HAS_ARG, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
ab6d194a
MN
2673 { "croptop", HAS_ARG, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
2674 { "cropbottom", HAS_ARG, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
2675 { "cropleft", HAS_ARG, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
2676 { "cropright", HAS_ARG, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
bdc4796f
FB
2677 { "g", HAS_ARG | OPT_EXPERT, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
2678 { "intra", OPT_BOOL | OPT_EXPERT, {(void*)&intra_only}, "use only intra frames"},
2679 { "vn", OPT_BOOL, {(void*)&video_disable}, "disable video" },
2680 { "qscale", HAS_ARG | OPT_EXPERT, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
9cdd6a24
MN
2681 { "qmin", HAS_ARG | OPT_EXPERT, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
2682 { "qmax", HAS_ARG | OPT_EXPERT, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
17a70fde
MN
2683 { "mbqmin", HAS_ARG | OPT_EXPERT, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
2684 { "mbqmax", HAS_ARG | OPT_EXPERT, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
9cdd6a24
MN
2685 { "qdiff", HAS_ARG | OPT_EXPERT, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
2686 { "qblur", HAS_ARG | OPT_EXPERT, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
2687 { "qcomp", HAS_ARG | OPT_EXPERT, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
ac2830ec 2688 { "rc_init_cplx", HAS_ARG | OPT_EXPERT, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
29700fa6
MN
2689 { "b_qfactor", HAS_ARG | OPT_EXPERT, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
2690 { "i_qfactor", HAS_ARG | OPT_EXPERT, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
2691 { "b_qoffset", HAS_ARG | OPT_EXPERT, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
2692 { "i_qoffset", HAS_ARG | OPT_EXPERT, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
59b571c1 2693// { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3aa102be 2694 { "rc_eq", HAS_ARG | OPT_EXPERT, {(void*)opt_video_rc_eq}, "", "equation" },
ac2830ec 2695 { "rc_override", HAS_ARG | OPT_EXPERT, {(void*)opt_video_rc_override_string}, "Rate control override", "qualities for specific intervals" },
9cdd6a24 2696 { "bt", HAS_ARG, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3aa102be
MN
2697 { "maxrate", HAS_ARG, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
2698 { "minrate", HAS_ARG, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
946c8a12 2699 { "bufsize", HAS_ARG, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kbit)", "size" },
bf5af568 2700 { "vd", HAS_ARG | OPT_EXPERT, {(void*)opt_video_device}, "set video grab device", "device" },
8aa3ee32 2701 { "dv1394", OPT_EXPERT, {(void*)opt_dv1394}, "set DV1394 options", "[channel]" },
1629626f 2702 { "vcodec", HAS_ARG | OPT_EXPERT, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
bdc4796f 2703 { "me", HAS_ARG | OPT_EXPERT, {(void*)opt_motion_estimation}, "set motion estimation method",
85f07f22 2704 "method" },
463678ac 2705 { "dct_algo", HAS_ARG | OPT_EXPERT, {(void*)opt_dct_algo}, "set dct algo", "algo" },
2ad1516a 2706 { "idct_algo", HAS_ARG | OPT_EXPERT, {(void*)opt_idct_algo}, "set idct algo", "algo" },
8409b8fe 2707 { "er", HAS_ARG | OPT_EXPERT, {(void*)opt_error_resilience}, "set error resilience", "" },
59b571c1 2708 { "ec", HAS_ARG | OPT_EXPERT, {(void*)opt_error_concealment}, "set error concealment", "" },
bc6caae2 2709 { "bf", HAS_ARG | OPT_EXPERT, {(void*)opt_b_frames}, "use 'frames' B frames (only MPEG-4)", "frames" },
e4986da9 2710 { "hq", OPT_BOOL | OPT_EXPERT, {(void*)&use_hq}, "activate high quality settings" },
29da453b 2711 { "4mv", OPT_BOOL | OPT_EXPERT, {(void*)&use_4mv}, "use four motion vector by macroblock (only MPEG-4)" },
1dbb6d90 2712 { "part", OPT_BOOL | OPT_EXPERT, {(void*)&use_part}, "use data partitioning (only MPEG-4)" },
fe670d09 2713 { "bug", HAS_ARG | OPT_EXPERT, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
1dbb6d90 2714 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "packet size", "size in bits" },
f560dd82 2715 { "strict", HAS_ARG | OPT_EXPERT, {(void*)opt_strict}, "strictness", "how strictly to follow the standarts" },
bdc4796f 2716 { "sameq", OPT_BOOL, {(void*)&same_quality},
85f07f22 2717 "use same video quality as source (implies VBR)" },
1d366fce 2718 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
85f07f22 2719 /* audio options */
bdc4796f
FB
2720 { "ab", HAS_ARG, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
2721 { "ar", HAS_ARG, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
2722 { "ac", HAS_ARG, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
2723 { "an", OPT_BOOL, {(void*)&audio_disable}, "disable audio" },
bdc4796f 2724 { "ad", HAS_ARG | OPT_EXPERT, {(void*)opt_audio_device}, "set audio device", "device" },
1629626f 2725 { "acodec", HAS_ARG | OPT_EXPERT, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
bdc4796f 2726 { "deinterlace", OPT_BOOL | OPT_EXPERT, {(void*)&do_deinterlace},
cfcf0ffd 2727 "deinterlace pictures" },
bdc4796f 2728 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5727b222 2729 "add timings for benchmarking" },
a0663ba4
FB
2730 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
2731 "dump each input packet" },
ce7c56c2
J
2732 { "psnr", OPT_BOOL | OPT_EXPERT, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
2733 { "vstats", OPT_BOOL | OPT_EXPERT, {(void*)&do_vstats}, "dump video coding statistics to file" },
79fdaa4c 2734 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
10d104e4 2735 { "vhook", HAS_ARG | OPT_EXPERT, {(void*)add_frame_hooker}, "insert video processing module", "module name and parameters" },
85f07f22
FB
2736 { NULL, },
2737};
2738
2739int main(int argc, char **argv)
2740{
2741 int optindex, i;
2742 const char *opt, *arg;
2743 const OptionDef *po;
a38469e1 2744 INT64 ti;
85f07f22 2745
2c4ae653 2746 av_register_all();
85f07f22 2747
a38469e1
FB
2748 /* detect if invoked as player */
2749 i = strlen(argv[0]);
2750 if (i >= 6 && !strcmp(argv[0] + i - 6, "ffplay"))
2751 do_play = 1;
2752
85f07f22
FB
2753 if (argc <= 1)
2754 show_help();
a38469e1
FB
2755
2756 /* parse options */
85f07f22
FB
2757 optindex = 1;
2758 while (optindex < argc) {
2759 opt = argv[optindex++];
2760
2761 if (opt[0] == '-' && opt[1] != '\0') {
2762 po = options;
2763 while (po->name != NULL) {
2764 if (!strcmp(opt + 1, po->name))
2765 break;
2766 po++;
2767 }
2768 if (!po->name) {
2769 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
2770 exit(1);
2771 }
2772 arg = NULL;
10d104e4 2773 if (po->flags & HAS_ARG) {
85f07f22 2774 arg = argv[optindex++];
10d104e4
PG
2775 if (!arg) {
2776 fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
2777 exit(1);
2778 }
2779 }
85f07f22
FB
2780 if (po->flags & OPT_STRING) {
2781 char *str;
2782 str = strdup(arg);
2783 *po->u.str_arg = str;
2784 } else if (po->flags & OPT_BOOL) {
2785 *po->u.int_arg = 1;
2786 } else {
2787 po->u.func_arg(arg);
2788 }
2789 } else {
a38469e1
FB
2790 if (!do_play) {
2791 opt_output_file(opt);
2792 } else {
2793 opt_input_file(opt);
2794 }
85f07f22
FB
2795 }
2796 }
2797
2798
a38469e1
FB
2799 if (!do_play) {
2800 /* file converter / grab */
85f07f22
FB
2801 if (nb_output_files <= 0) {
2802 fprintf(stderr, "Must supply at least one output file\n");
2803 exit(1);
2804 }
a38469e1
FB
2805
2806 if (nb_input_files == 0) {
2807 prepare_grab();
5727b222 2808 }
a38469e1
FB
2809 } else {
2810 /* player */
2811 if (nb_input_files <= 0) {
2812 fprintf(stderr, "Must supply at least one input file\n");
2813 exit(1);
2814 }
2815 prepare_play();
2816 }
2817
2818 ti = getutime();
2819 av_encode(output_files, nb_output_files, input_files, nb_input_files,
2820 stream_maps, nb_stream_maps);
2821 ti = getutime() - ti;
2822 if (do_benchmark) {
2823 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
85f07f22
FB
2824 }
2825
2826 /* close files */
2827 for(i=0;i<nb_output_files;i++) {
4fca59f2
ZK
2828 /* maybe av_close_output_file ??? */
2829 AVFormatContext *s = output_files[i];
2830 int j;
2831 if (!(s->oformat->flags & AVFMT_NOFILE))
2832 url_fclose(&s->pb);
2833 for(j=0;j<s->nb_streams;j++)
2834 av_free(s->streams[j]);
2835 av_free(s);
85f07f22 2836 }
79fdaa4c
FB
2837 for(i=0;i<nb_input_files;i++)
2838 av_close_input_file(input_files[i]);
85f07f22 2839
855ea723 2840 av_free_static();
db40a39a
MN
2841
2842
35e5fb06
RD
2843#ifdef POWERPC_TBL_PERFORMANCE_REPORT
2844 extern void powerpc_display_perf_report(void);
2845 powerpc_display_perf_report();
2846#endif /* POWERPC_TBL_PERFORMANCE_REPORT */
db40a39a 2847
85f07f22
FB
2848 return 0;
2849}