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