Add the prefix "av_" to img_crop(), img_copy() and img_pad(), and rename "img"
[libav.git] / ffmpeg.c
CommitLineData
85f07f22 1/*
115329f1 2 * FFmpeg main
01310af2 3 * Copyright (c) 2000-2003 Fabrice Bellard
85f07f22 4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
bf5af568
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
85f07f22 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
85f07f22 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
bf5af568
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
85f07f22 16 *
bf5af568 17 * You should have received a copy of the GNU Lesser General Public
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
85f07f22 20 */
daf8e955 21#define HAVE_AV_CONFIG_H
d86b83f8 22#include <signal.h>
22f7a060 23#include <limits.h>
daf8e955 24#include "avformat.h"
18a54b04 25#include "swscale.h"
10d104e4 26#include "framehook.h"
1ac31760 27#include "dsputil.h"
6fd46414 28#include "opt.h"
f5a478f6 29#include "fifo.h"
daf8e955 30
d86b83f8
RP
31#ifdef __MINGW32__
32#include <conio.h>
33#else
85f07f22
FB
34#include <unistd.h>
35#include <fcntl.h>
36#include <sys/ioctl.h>
85f07f22 37#include <sys/time.h>
85f07f22 38#include <termios.h>
5727b222 39#include <sys/resource.h>
bdc4796f 40#endif
f3ec2d46
SG
41#ifdef CONFIG_OS2
42#include <sys/types.h>
43#include <sys/select.h>
44#include <stdlib.h>
45#endif
64c020a8 46#undef time //needed because HAVE_AV_CONFIG_H is defined on top
bf5af568 47#include <time.h>
85f07f22 48
f1cc88a5 49#include "version.h"
01310af2
FB
50#include "cmdutils.h"
51
2b18dcd0
MN
52#undef NDEBUG
53#include <assert.h>
54
8aa1e3da
MN
55#if !defined(INFINITY) && defined(HUGE_VAL)
56#define INFINITY HUGE_VAL
57#endif
85f07f22 58
85f07f22
FB
59/* select an input stream for an output stream */
60typedef struct AVStreamMap {
61 int file_index;
62 int stream_index;
b4a3389e
WG
63 int sync_file_index;
64 int sync_stream_index;
85f07f22
FB
65} AVStreamMap;
66
0a38bafd
PB
67/** select an input file for an output file */
68typedef struct AVMetaDataMap {
69 int out_file;
70 int in_file;
71} AVMetaDataMap;
72
85f07f22
FB
73extern const OptionDef options[];
74
02d504a7
FB
75static void show_help(void);
76static void show_license(void);
637b5326 77static int opt_default(const char *opt, const char *arg);
85f07f22
FB
78
79#define MAX_FILES 20
80
81static AVFormatContext *input_files[MAX_FILES];
a6a92a9a 82static int64_t input_files_ts_offset[MAX_FILES];
85f07f22
FB
83static int nb_input_files = 0;
84
85static AVFormatContext *output_files[MAX_FILES];
86static int nb_output_files = 0;
87
88static AVStreamMap stream_maps[MAX_FILES];
89static int nb_stream_maps;
90
0a38bafd
PB
91static AVMetaDataMap meta_data_maps[MAX_FILES];
92static int nb_meta_data_maps;
93
79fdaa4c
FB
94static AVInputFormat *file_iformat;
95static AVOutputFormat *file_oformat;
55cf1959
MN
96static int frame_width = 0;
97static int frame_height = 0;
880e8ba7 98static float frame_aspect_ratio = 0;
644a9262 99static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
1ff93ffc
TK
100static int frame_padtop = 0;
101static int frame_padbottom = 0;
102static int frame_padleft = 0;
103static int frame_padright = 0;
104static int padcolor[3] = {16,128,128}; /* default to black */
ab6d194a
MN
105static int frame_topBand = 0;
106static int frame_bottomBand = 0;
107static int frame_leftBand = 0;
108static int frame_rightBand = 0;
cf7fc795 109static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
14bea432
MN
110static int frame_rate = 25;
111static int frame_rate_base = 1;
158c7f05 112static float video_qscale = 0;
9cdd6a24 113static int video_qdiff = 3;
84f608f4
VM
114static uint16_t *intra_matrix = NULL;
115static uint16_t *inter_matrix = NULL;
ac2830ec 116#if 0 //experimental, (can be removed)
3aa102be
MN
117static float video_rc_qsquish=1.0;
118static float video_rc_qmod_amp=0;
119static int video_rc_qmod_freq=0;
ac2830ec 120#endif
3aa102be
MN
121static char *video_rc_override_string=NULL;
122static char *video_rc_eq="tex^qComp";
3bea5386 123static int me_method = ME_EPZS;
85f07f22 124static int video_disable = 0;
f3356e9c 125static int video_discard = 0;
85f07f22 126static int video_codec_id = CODEC_ID_NONE;
b2a2197e 127static int video_codec_tag = 0;
85f07f22 128static int same_quality = 0;
cfcf0ffd 129static int do_deinterlace = 0;
f560dd82 130static int strict = 0;
bb198e19 131static int top_field_first = -1;
f4f3223f 132static int me_threshold = 0;
1a11cbcc 133static int intra_dc_precision = 8;
5894e1bb 134static int loop_input = 0;
8108551a 135static int loop_output = AVFMT_NOOUTPUTLOOP;
0888fd22 136static int qp_hist = 0;
85f07f22 137
85f07f22
FB
138static int intra_only = 0;
139static int audio_sample_rate = 44100;
140static int audio_bit_rate = 64000;
c57c770d
JR
141#define QSCALE_NONE -99999
142static float audio_qscale = QSCALE_NONE;
85f07f22
FB
143static int audio_disable = 0;
144static int audio_channels = 1;
145static int audio_codec_id = CODEC_ID_NONE;
b2a2197e 146static int audio_codec_tag = 0;
cf7fc795
FB
147static char *audio_language = NULL;
148
149static int subtitle_codec_id = CODEC_ID_NONE;
150static char *subtitle_language = NULL;
85f07f22 151
17c88cb0
MN
152static float mux_preload= 0.5;
153static float mux_max_delay= 0.7;
2db3c638 154
0c1a9eda 155static int64_t recording_time = 0;
8831db5c 156static int64_t start_time = 0;
4568325a 157static int64_t rec_timestamp = 0;
a6a92a9a 158static int64_t input_ts_offset = 0;
85f07f22
FB
159static int file_overwrite = 0;
160static char *str_title = NULL;
161static char *str_author = NULL;
162static char *str_copyright = NULL;
163static char *str_comment = NULL;
63d5075c 164static char *str_album = NULL;
5727b222 165static int do_benchmark = 0;
a0663ba4 166static int do_hex_dump = 0;
254abc2e 167static int do_pkt_dump = 0;
43f1708f 168static int do_psnr = 0;
ce7c56c2 169static int do_vstats = 0;
5abdb4b1
FB
170static int do_pass = 0;
171static char *pass_logfilename = NULL;
1629626f
FB
172static int audio_stream_copy = 0;
173static int video_stream_copy = 0;
cf7fc795 174static int subtitle_stream_copy = 0;
986ebcdb
MN
175static int video_sync_method= 1;
176static int audio_sync_method= 0;
72bd8100 177static int copy_ts= 0;
ca80810b 178static int opt_shortest = 0; //
90ad92b3 179static int video_global_header = 0;
5abdb4b1 180
bdfcbbed
MK
181static int rate_emu = 0;
182
a5df11ab 183static int video_channel = 0;
e3ee3283 184static char *video_standard = "ntsc";
79a7c268 185
a9aa3467 186static int audio_volume = 256;
8aa3ee32 187
d9a916e2 188static int using_stdin = 0;
bee0d9e5 189static int using_vhook = 0;
f068206e 190static int verbose = 1;
9c3d33d6 191static int thread_count= 1;
b51469a0 192static int q_pressed = 0;
1008ceb3
MN
193static int64_t video_size = 0;
194static int64_t audio_size = 0;
195static int64_t extra_size = 0;
a6a92a9a
WG
196static int nb_frames_dup = 0;
197static int nb_frames_drop = 0;
6e454c38 198static int input_sync;
b6e16b86 199static int limit_filesize = 0; //
d9a916e2 200
5b6d5596 201static int pgmyuv_compatibility_hack=0;
023857be 202static int dts_delta_threshold = 10;
5b6d5596 203
18a54b04
LA
204static int sws_flags = SWS_BICUBIC;
205
8bbf6db9
MN
206const char **opt_names=NULL;
207int opt_name_count=0;
23b254fb 208AVCodecContext *avctx_opts[CODEC_TYPE_NB];
4eb72c6b 209AVFormatContext *avformat_opts;
8bbf6db9 210
748c2fca
MN
211static AVBitStreamFilterContext *video_bitstream_filters=NULL;
212static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
213static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
5b6d5596 214
5abdb4b1 215#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
85f07f22 216
b4a3389e
WG
217struct AVInputStream;
218
85f07f22
FB
219typedef struct AVOutputStream {
220 int file_index; /* file index */
221 int index; /* stream index in the output file */
222 int source_index; /* AVInputStream index */
223 AVStream *st; /* stream in the output file */
ec5517d5
FB
224 int encoding_needed; /* true if encoding needed for this stream */
225 int frame_number;
226 /* input pts and corresponding output pts
227 for A/V sync */
b4a3389e
WG
228 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
229 struct AVInputStream *sync_ist; /* input stream to sync against */
e928649b 230 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
85f07f22 231 /* video only */
07d0cdfc 232 int video_resample;
a4d36c11 233 AVFrame pict_tmp; /* temporary image for resampling */
18a54b04
LA
234 struct SwsContext *img_resample_ctx; /* for image resampling */
235 int resample_height;
34b10a57 236
07d0cdfc 237 int video_crop;
34b10a57
D
238 int topBand; /* cropping area sizes */
239 int leftBand;
115329f1 240
07d0cdfc 241 int video_pad;
1ff93ffc
TK
242 int padtop; /* padding area sizes */
243 int padbottom;
244 int padleft;
245 int padright;
115329f1 246
85f07f22
FB
247 /* audio only */
248 int audio_resample;
249 ReSampleContext *resample; /* for audio resampling */
f5a478f6 250 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
5abdb4b1 251 FILE *logfile;
85f07f22
FB
252} AVOutputStream;
253
254typedef struct AVInputStream {
255 int file_index;
256 int index;
257 AVStream *st;
258 int discard; /* true if stream data should be discarded */
259 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
0c1a9eda 260 int64_t sample_index; /* current sample */
bdfcbbed
MK
261
262 int64_t start; /* time when read started */
263 unsigned long frame; /* current frame */
254abc2e
FB
264 int64_t next_pts; /* synthetic pts for cases where pkt.pts
265 is not defined */
e7d0374f 266 int64_t pts; /* current pts */
ff4905a5 267 int is_start; /* is 1 at the start and after a discontinuity */
85f07f22
FB
268} AVInputStream;
269
270typedef struct AVInputFile {
271 int eof_reached; /* true if eof reached */
272 int ist_index; /* index of first stream in ist_table */
273 int buffer_size; /* current total buffer size */
274 int buffer_size_max; /* buffer size at which we consider we can stop
275 buffering */
79fdaa4c 276 int nb_streams; /* nb streams we are aware of */
85f07f22
FB
277} AVInputFile;
278
2f30a81d 279#ifndef __MINGW32__
bdc4796f 280
85f07f22
FB
281/* init terminal so that we can grab keys */
282static struct termios oldtty;
d86b83f8 283#endif
85f07f22
FB
284
285static void term_exit(void)
286{
d86b83f8 287#ifndef __MINGW32__
85f07f22 288 tcsetattr (0, TCSANOW, &oldtty);
d86b83f8 289#endif
85f07f22
FB
290}
291
9680a722
RP
292static volatile sig_atomic_t received_sigterm = 0;
293
294static void
295sigterm_handler(int sig)
296{
297 received_sigterm = sig;
298 term_exit();
299}
300
85f07f22
FB
301static void term_init(void)
302{
d86b83f8 303#ifndef __MINGW32__
85f07f22
FB
304 struct termios tty;
305
306 tcgetattr (0, &tty);
307 oldtty = tty;
308
309 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
310 |INLCR|IGNCR|ICRNL|IXON);
311 tty.c_oflag |= OPOST;
312 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
313 tty.c_cflag &= ~(CSIZE|PARENB);
314 tty.c_cflag |= CS8;
315 tty.c_cc[VMIN] = 1;
316 tty.c_cc[VTIME] = 0;
115329f1 317
85f07f22 318 tcsetattr (0, TCSANOW, &tty);
d86b83f8
RP
319 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
320#endif
85f07f22 321
9680a722 322 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
9680a722
RP
323 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
324 /*
325 register a function to be called at normal program termination
326 */
85f07f22 327 atexit(term_exit);
9ddd71fc
FR
328#ifdef CONFIG_BEOS_NETSERVER
329 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
330#endif
85f07f22
FB
331}
332
333/* read a key without blocking */
334static int read_key(void)
335{
d86b83f8
RP
336#ifdef __MINGW32__
337 if(kbhit())
338 return(getch());
339#else
9ddd71fc 340 int n = 1;
85f07f22 341 unsigned char ch;
9ddd71fc
FR
342#ifndef CONFIG_BEOS_NETSERVER
343 struct timeval tv;
85f07f22
FB
344 fd_set rfds;
345
346 FD_ZERO(&rfds);
347 FD_SET(0, &rfds);
348 tv.tv_sec = 0;
349 tv.tv_usec = 0;
350 n = select(1, &rfds, NULL, NULL, &tv);
9ddd71fc 351#endif
85f07f22 352 if (n > 0) {
cb09b2ed
PG
353 n = read(0, &ch, 1);
354 if (n == 1)
85f07f22 355 return ch;
cb09b2ed
PG
356
357 return n;
85f07f22 358 }
d86b83f8 359#endif
85f07f22
FB
360 return -1;
361}
362
b51469a0
LS
363static int decode_interrupt_cb(void)
364{
365 return q_pressed || (q_pressed = read_key() == 'q');
366}
367
b29f97d1 368static int read_ffserver_streams(AVFormatContext *s, const char *filename)
85f07f22 369{
79fdaa4c 370 int i, err;
85f07f22
FB
371 AVFormatContext *ic;
372
79fdaa4c
FB
373 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
374 if (err < 0)
375 return err;
85f07f22
FB
376 /* copy stream format */
377 s->nb_streams = ic->nb_streams;
378 for(i=0;i<ic->nb_streams;i++) {
379 AVStream *st;
1e491e29 380
f37f8d4c 381 // FIXME: a more elegant solution is needed
e1031171 382 st = av_mallocz(sizeof(AVStream));
85f07f22 383 memcpy(st, ic->streams[i], sizeof(AVStream));
f37f8d4c
AB
384 st->codec = avcodec_alloc_context();
385 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
85f07f22
FB
386 s->streams[i] = st;
387 }
388
389 av_close_input_file(ic);
390 return 0;
391}
392
b4a3389e
WG
393static double
394get_sync_ipts(const AVOutputStream *ost)
395{
396 const AVInputStream *ist = ost->sync_ist;
397 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
398}
399
748c2fca
MN
400static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
401 while(bsfc){
402 AVPacket new_pkt= *pkt;
403 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
404 &new_pkt.data, &new_pkt.size,
405 pkt->data, pkt->size,
406 pkt->flags & PKT_FLAG_KEY);
407 if(a){
408 av_free_packet(pkt);
409 new_pkt.destruct= av_destruct_packet;
410 }
411 *pkt= new_pkt;
412
413 bsfc= bsfc->next;
414 }
415
416 av_interleaved_write_frame(s, pkt);
417}
418
817b23ff 419#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
85f07f22 420
115329f1
DB
421static void do_audio_out(AVFormatContext *s,
422 AVOutputStream *ost,
85f07f22
FB
423 AVInputStream *ist,
424 unsigned char *buf, int size)
425{
0c1a9eda 426 uint8_t *buftmp;
d66c7abc
SC
427 static uint8_t *audio_buf = NULL;
428 static uint8_t *audio_out = NULL;
558eae03 429 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
d66c7abc 430
85f07f22 431 int size_out, frame_bytes, ret;
01f4895c 432 AVCodecContext *enc= ost->st->codec;
85f07f22 433
d66c7abc
SC
434 /* SC: dynamic allocation of buffers */
435 if (!audio_buf)
436 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
437 if (!audio_out)
558eae03 438 audio_out = av_malloc(audio_out_size);
d66c7abc
SC
439 if (!audio_buf || !audio_out)
440 return; /* Should signal an error ! */
441
986ebcdb 442 if(audio_sync_method){
115329f1 443 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
f5a478f6 444 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
01f4895c
MN
445 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
446 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
ff4905a5 447
986ebcdb
MN
448 //FIXME resample delay
449 if(fabs(delta) > 50){
ff4905a5
MN
450 if(ist->is_start){
451 if(byte_delta < 0){
f41dd5aa 452 byte_delta= FFMAX(byte_delta, -size);
ff4905a5
MN
453 size += byte_delta;
454 buf -= byte_delta;
455 if(verbose > 2)
456 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
457 if(!size)
458 return;
459 ist->is_start=0;
460 }else{
461 static uint8_t *input_tmp= NULL;
462 input_tmp= av_realloc(input_tmp, byte_delta + size);
463
464 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
465 ist->is_start=0;
466 else
467 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
468
469 memset(input_tmp, 0, byte_delta);
470 memcpy(input_tmp + byte_delta, buf, size);
471 buf= input_tmp;
472 size += byte_delta;
473 if(verbose > 2)
474 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
475 }
476 }else if(audio_sync_method>1){
f66e4f5f 477 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
ff4905a5
MN
478 assert(ost->audio_resample);
479 if(verbose > 2)
480 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
949b1a13 481// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
ff4905a5
MN
482 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
483 }
115329f1 484 }
986ebcdb 485 }else
b4a3389e 486 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
f5a478f6 487 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
85f07f22
FB
488
489 if (ost->audio_resample) {
490 buftmp = audio_buf;
115329f1 491 size_out = audio_resample(ost->resample,
85f07f22 492 (short *)buftmp, (short *)buf,
01f4895c 493 size / (ist->st->codec->channels * 2));
85f07f22
FB
494 size_out = size_out * enc->channels * 2;
495 } else {
496 buftmp = buf;
497 size_out = size;
498 }
499
500 /* now encode as many frames as possible */
a0663ba4 501 if (enc->frame_size > 1) {
85f07f22 502 /* output resampled raw samples */
f5a478f6 503 av_fifo_write(&ost->fifo, buftmp, size_out);
85f07f22
FB
504
505 frame_bytes = enc->frame_size * 2 * enc->channels;
115329f1 506
f5a478f6 507 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
e928649b
MN
508 AVPacket pkt;
509 av_init_packet(&pkt);
510
115329f1 511 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
a0663ba4 512 (short *)audio_buf);
1008ceb3 513 audio_size += ret;
e928649b
MN
514 pkt.stream_index= ost->index;
515 pkt.data= audio_out;
516 pkt.size= ret;
e7902f20 517 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 518 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
e928649b 519 pkt.flags |= PKT_FLAG_KEY;
748c2fca 520 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
115329f1 521
986ebcdb 522 ost->sync_opts += enc->frame_size;
85f07f22
FB
523 }
524 } else {
e928649b
MN
525 AVPacket pkt;
526 av_init_packet(&pkt);
986ebcdb 527
c43042a7 528 ost->sync_opts += size_out / (2 * enc->channels);
986ebcdb 529
a0663ba4
FB
530 /* output a pcm frame */
531 /* XXX: change encoding codec API to avoid this ? */
532 switch(enc->codec->id) {
b461b3bc
RD
533 case CODEC_ID_PCM_S32LE:
534 case CODEC_ID_PCM_S32BE:
535 case CODEC_ID_PCM_U32LE:
536 case CODEC_ID_PCM_U32BE:
537 size_out = size_out << 1;
538 break;
539 case CODEC_ID_PCM_S24LE:
540 case CODEC_ID_PCM_S24BE:
541 case CODEC_ID_PCM_U24LE:
542 case CODEC_ID_PCM_U24BE:
543 case CODEC_ID_PCM_S24DAUD:
544 size_out = size_out / 2 * 3;
545 break;
a0663ba4
FB
546 case CODEC_ID_PCM_S16LE:
547 case CODEC_ID_PCM_S16BE:
548 case CODEC_ID_PCM_U16LE:
549 case CODEC_ID_PCM_U16BE:
550 break;
551 default:
552 size_out = size_out >> 1;
553 break;
554 }
115329f1 555 ret = avcodec_encode_audio(enc, audio_out, size_out,
bb270c08 556 (short *)buftmp);
1008ceb3 557 audio_size += ret;
e928649b
MN
558 pkt.stream_index= ost->index;
559 pkt.data= audio_out;
560 pkt.size= ret;
e7902f20 561 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 562 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
e928649b 563 pkt.flags |= PKT_FLAG_KEY;
748c2fca 564 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
85f07f22
FB
565 }
566}
567
10d104e4
PG
568static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
569{
570 AVCodecContext *dec;
571 AVPicture *picture2;
572 AVPicture picture_tmp;
0c1a9eda 573 uint8_t *buf = 0;
10d104e4 574
01f4895c 575 dec = ist->st->codec;
10d104e4
PG
576
577 /* deinterlace : must be done before any resize */
bee0d9e5 578 if (do_deinterlace || using_vhook) {
10d104e4
PG
579 int size;
580
581 /* create temporary picture */
582 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
583 buf = av_malloc(size);
584 if (!buf)
585 return;
115329f1 586
10d104e4
PG
587 picture2 = &picture_tmp;
588 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
589
dafc3856 590 if (do_deinterlace){
115329f1 591 if(avpicture_deinterlace(picture2, picture,
dafc3856
MN
592 dec->pix_fmt, dec->width, dec->height) < 0) {
593 /* if error, do not deinterlace */
594 av_free(buf);
595 buf = NULL;
596 picture2 = picture;
597 }
598 } else {
636d6a4a 599 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
bee0d9e5 600 }
10d104e4
PG
601 } else {
602 picture2 = picture;
603 }
604
605 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
606
607 if (picture != picture2)
608 *picture = *picture2;
609 *bufp = buf;
610}
611
ec5517d5
FB
612/* we begin to correct av delay at this threshold */
613#define AV_DELAY_MAX 0.100
85f07f22 614
115329f1
DB
615static void do_subtitle_out(AVFormatContext *s,
616 AVOutputStream *ost,
cf7fc795
FB
617 AVInputStream *ist,
618 AVSubtitle *sub,
619 int64_t pts)
620{
621 static uint8_t *subtitle_out = NULL;
622 int subtitle_out_max_size = 65536;
623 int subtitle_out_size, nb, i;
624 AVCodecContext *enc;
625 AVPacket pkt;
626
627 if (pts == AV_NOPTS_VALUE) {
628 fprintf(stderr, "Subtitle packets must have a pts\n");
629 return;
630 }
631
01f4895c 632 enc = ost->st->codec;
cf7fc795
FB
633
634 if (!subtitle_out) {
635 subtitle_out = av_malloc(subtitle_out_max_size);
636 }
637
638 /* Note: DVB subtitle need one packet to draw them and one other
639 packet to clear them */
640 /* XXX: signal it in the codec context ? */
641 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
642 nb = 2;
643 else
644 nb = 1;
645
646 for(i = 0; i < nb; i++) {
115329f1 647 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
cf7fc795 648 subtitle_out_max_size, sub);
115329f1 649
cf7fc795
FB
650 av_init_packet(&pkt);
651 pkt.stream_index = ost->index;
652 pkt.data = subtitle_out;
653 pkt.size = subtitle_out_size;
654 pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
655 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
656 /* XXX: the pts correction is handled here. Maybe handling
657 it in the codec would be better */
658 if (i == 0)
659 pkt.pts += 90 * sub->start_display_time;
660 else
661 pkt.pts += 90 * sub->end_display_time;
662 }
748c2fca 663 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
cf7fc795
FB
664 }
665}
666
8a6cb114 667static int bit_buffer_size= 1024*256;
27537106 668static uint8_t *bit_buffer= NULL;
1ff93ffc 669
115329f1
DB
670static void do_video_out(AVFormatContext *s,
671 AVOutputStream *ost,
85f07f22 672 AVInputStream *ist,
7a0f9d7e 673 AVFrame *in_picture,
986ebcdb 674 int *frame_size)
85f07f22 675{
ec5517d5 676 int nb_frames, i, ret;
07d0cdfc 677 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
18a54b04 678 AVFrame picture_crop_temp, picture_pad_temp;
0c1a9eda 679 uint8_t *buf = NULL, *buf1 = NULL;
cfcf0ffd 680 AVCodecContext *enc, *dec;
115329f1 681
a4d36c11 682 avcodec_get_frame_defaults(&picture_crop_temp);
07d0cdfc 683 avcodec_get_frame_defaults(&picture_pad_temp);
a4d36c11 684
01f4895c
MN
685 enc = ost->st->codec;
686 dec = ist->st->codec;
85f07f22 687
ec5517d5
FB
688 /* by default, we output a single frame */
689 nb_frames = 1;
690
204c0f48
PG
691 *frame_size = 0;
692
986ebcdb 693 if(video_sync_method){
10d104e4 694 double vdelta;
b4a3389e 695 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
e928649b
MN
696 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
697 if (vdelta < -1.1)
698 nb_frames = 0;
699 else if (vdelta > 1.1)
70122f29 700 nb_frames = lrintf(vdelta);
949b1a13 701//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
50c3dd32
MN
702 if (nb_frames == 0){
703 ++nb_frames_drop;
704 if (verbose>2)
705 fprintf(stderr, "*** drop!\n");
8300609b
MN
706 }else if (nb_frames > 1) {
707 nb_frames_dup += nb_frames;
50c3dd32 708 if (verbose>2)
8300609b 709 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
50c3dd32
MN
710 }
711 }else
b4a3389e 712 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
445f1b83 713
7ca60994 714 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
115329f1 715 if (nb_frames <= 0)
85f07f22 716 return;
ce7c56c2 717
07d0cdfc 718 if (ost->video_crop) {
636d6a4a 719 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
07d0cdfc
LA
720 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
721 goto the_end;
722 }
723 formatted_picture = &picture_crop_temp;
18a54b04
LA
724 } else {
725 formatted_picture = in_picture;
07d0cdfc
LA
726 }
727
728 final_picture = formatted_picture;
729 padding_src = formatted_picture;
730 resampling_dst = &ost->pict_tmp;
731 if (ost->video_pad) {
732 final_picture = &ost->pict_tmp;
733 if (ost->video_resample) {
636d6a4a 734 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
07d0cdfc
LA
735 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
736 goto the_end;
737 }
738 resampling_dst = &picture_pad_temp;
739 }
740 }
741
85f07f22 742 if (ost->video_resample) {
07d0cdfc 743 padding_src = NULL;
34b10a57 744 final_picture = &ost->pict_tmp;
18a54b04
LA
745 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
746 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
f122deb4 747 }
07d0cdfc
LA
748
749 if (ost->video_pad) {
636d6a4a 750 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
07d0cdfc
LA
751 enc->height, enc->width, enc->pix_fmt,
752 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
85f07f22 753 }
07d0cdfc 754
85f07f22 755 /* duplicates frame if needed */
ec5517d5 756 for(i=0;i<nb_frames;i++) {
e928649b
MN
757 AVPacket pkt;
758 av_init_packet(&pkt);
759 pkt.stream_index= ost->index;
760
e8750b00
FR
761 if (s->oformat->flags & AVFMT_RAWPICTURE) {
762 /* raw pictures are written as AVPicture structure to
763 avoid any copies. We support temorarily the older
764 method. */
2744ca9a 765 AVFrame* old_frame = enc->coded_frame;
bb270c08 766 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
e928649b
MN
767 pkt.data= (uint8_t *)final_picture;
768 pkt.size= sizeof(AVPicture);
e7902f20 769 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 770 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
e928649b
MN
771 if(dec->coded_frame && dec->coded_frame->key_frame)
772 pkt.flags |= PKT_FLAG_KEY;
773
748c2fca 774 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
bb270c08 775 enc->coded_frame = old_frame;
e8750b00 776 } else {
492cd3a9 777 AVFrame big_picture;
a4d36c11
MN
778
779 big_picture= *final_picture;
7a0f9d7e
FB
780 /* better than nothing: use input picture interlaced
781 settings */
782 big_picture.interlaced_frame = in_picture->interlaced_frame;
23b254fb 783 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
bb198e19
MN
784 if(top_field_first == -1)
785 big_picture.top_field_first = in_picture->top_field_first;
786 else
2a8edc5d 787 big_picture.top_field_first = top_field_first;
bb198e19 788 }
7a0f9d7e 789
85f07f22
FB
790 /* handles sameq here. This is not correct because it may
791 not be a global option */
792 if (same_quality) {
1e491e29
MN
793 big_picture.quality = ist->st->quality;
794 }else
795 big_picture.quality = ost->st->quality;
f4f3223f
MN
796 if(!me_threshold)
797 big_picture.pict_type = 0;
50c3dd32 798// big_picture.pts = AV_NOPTS_VALUE;
c0df9d75
MN
799 big_picture.pts= ost->sync_opts;
800// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
949b1a13 801//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
115329f1 802 ret = avcodec_encode_video(enc,
8a6cb114 803 bit_buffer, bit_buffer_size,
1e491e29 804 &big_picture);
4156a436
PI
805 if (ret == -1) {
806 fprintf(stderr, "Video encoding failed\n");
807 exit(1);
808 }
44429457 809 //enc->frame_number = enc->real_pict_num;
4bbc6260 810 if(ret>0){
27537106 811 pkt.data= bit_buffer;
e928649b 812 pkt.size= ret;
e7902f20 813 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 814 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
949b1a13 815/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
c0df9d75
MN
816 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
817 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
50c3dd32 818
e928649b
MN
819 if(enc->coded_frame && enc->coded_frame->key_frame)
820 pkt.flags |= PKT_FLAG_KEY;
748c2fca 821 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
e928649b
MN
822 *frame_size = ret;
823 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
824 // enc->frame_number-1, enc->real_pict_num, ret,
825 // enc->pict_type);
826 /* if two pass, output log */
827 if (ost->logfile && enc->stats_out) {
828 fprintf(ost->logfile, "%s", enc->stats_out);
829 }
5abdb4b1 830 }
85f07f22 831 }
50c3dd32 832 ost->sync_opts++;
ec5517d5 833 ost->frame_number++;
85f07f22 834 }
ec5517d5 835 the_end:
0f1578af
FB
836 av_free(buf);
837 av_free(buf1);
85f07f22
FB
838}
839
140cb663
MN
840static double psnr(double d){
841 if(d==0) return INFINITY;
b29f97d1 842 return -10.0*log(d)/log(10.0);
140cb663
MN
843}
844
115329f1 845static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
ec5517d5 846 int frame_size)
ce7c56c2
J
847{
848 static FILE *fvstats=NULL;
ce7c56c2 849 char filename[40];
bf5af568
FB
850 time_t today2;
851 struct tm *today;
ce7c56c2
J
852 AVCodecContext *enc;
853 int frame_number;
0c1a9eda 854 int64_t ti;
ce7c56c2 855 double ti1, bitrate, avg_bitrate;
115329f1 856
ce7c56c2
J
857 if (!fvstats) {
858 today2 = time(NULL);
859 today = localtime(&today2);
2fc8ea24 860 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
ce7c56c2
J
861 today->tm_min,
862 today->tm_sec);
863 fvstats = fopen(filename,"w");
864 if (!fvstats) {
865 perror("fopen");
866 exit(1);
867 }
868 }
115329f1 869
f27a7268 870 ti = INT64_MAX;
01f4895c 871 enc = ost->st->codec;
ce7c56c2 872 if (enc->codec_type == CODEC_TYPE_VIDEO) {
ec5517d5 873 frame_number = ost->frame_number;
158c7f05 874 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
140cb663 875 if (enc->flags&CODEC_FLAG_PSNR)
492cd3a9 876 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
115329f1 877
ce7c56c2 878 fprintf(fvstats,"f_size= %6d ", frame_size);
ec5517d5 879 /* compute pts value */
c0df9d75 880 ti1 = ost->sync_opts * av_q2d(enc->time_base);
ce7c56c2
J
881 if (ti1 < 0.01)
882 ti1 = 0.01;
115329f1 883
c0df9d75 884 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1008ceb3 885 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
ce7c56c2 886 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1008ceb3 887 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
115329f1 888 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
ce7c56c2 889 }
ec5517d5
FB
890}
891
b29f97d1 892static void print_report(AVFormatContext **output_files,
bb270c08
DB
893 AVOutputStream **ost_table, int nb_ostreams,
894 int is_last_report)
ec5517d5
FB
895{
896 char buf[1024];
897 AVOutputStream *ost;
898 AVFormatContext *oc, *os;
0c1a9eda 899 int64_t total_size;
ec5517d5
FB
900 AVCodecContext *enc;
901 int frame_number, vid, i;
902 double bitrate, ti1, pts;
0c1a9eda 903 static int64_t last_time = -1;
0888fd22 904 static int qp_histogram[52];
115329f1 905
ec5517d5 906 if (!is_last_report) {
0c1a9eda 907 int64_t cur_time;
ec5517d5
FB
908 /* display the report every 0.5 seconds */
909 cur_time = av_gettime();
910 if (last_time == -1) {
911 last_time = cur_time;
912 return;
115329f1 913 }
ec5517d5
FB
914 if ((cur_time - last_time) < 500000)
915 return;
916 last_time = cur_time;
917 }
918
ce7c56c2 919
ec5517d5
FB
920 oc = output_files[0];
921
922 total_size = url_ftell(&oc->pb);
115329f1 923
ec5517d5
FB
924 buf[0] = '\0';
925 ti1 = 1e10;
926 vid = 0;
927 for(i=0;i<nb_ostreams;i++) {
928 ost = ost_table[i];
929 os = output_files[ost->file_index];
01f4895c 930 enc = ost->st->codec;
10d104e4 931 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
0ecca7a4 932 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
158c7f05 933 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
10d104e4 934 }
ec5517d5
FB
935 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
936 frame_number = ost->frame_number;
0888fd22
MN
937 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
938 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
890972be 939 if(is_last_report)
0ecca7a4 940 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
0888fd22
MN
941 if(qp_hist && enc->coded_frame){
942 int j;
943 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
944 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
945 qp_histogram[qp]++;
946 for(j=0; j<32; j++)
947 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
948 }
890972be
MN
949 if (enc->flags&CODEC_FLAG_PSNR){
950 int j;
951 double error, error_sum=0;
952 double scale, scale_sum=0;
953 char type[3]= {'Y','U','V'};
0ecca7a4 954 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
890972be
MN
955 for(j=0; j<3; j++){
956 if(is_last_report){
957 error= enc->error[j];
958 scale= enc->width*enc->height*255.0*255.0*frame_number;
959 }else{
960 error= enc->coded_frame->error[j];
961 scale= enc->width*enc->height*255.0*255.0;
962 }
963 if(j) scale/=4;
964 error_sum += error;
965 scale_sum += scale;
0ecca7a4 966 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
890972be 967 }
0ecca7a4 968 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
890972be 969 }
ec5517d5
FB
970 vid = 1;
971 }
972 /* compute min output value */
9ee91c2f 973 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
5d9827bc 974 if ((pts < ti1) && (pts > 0))
ec5517d5
FB
975 ti1 = pts;
976 }
977 if (ti1 < 0.01)
978 ti1 = 0.01;
115329f1 979
f068206e
BE
980 if (verbose || is_last_report) {
981 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
115329f1
DB
982
983 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
ec5517d5
FB
984 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
985 (double)total_size / 1024, ti1, bitrate);
a6a92a9a 986
bb270c08
DB
987 if (verbose > 1)
988 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
989 nb_frames_dup, nb_frames_drop);
115329f1 990
d8019eb5
AD
991 if (verbose >= 0)
992 fprintf(stderr, "%s \r", buf);
993
ec5517d5
FB
994 fflush(stderr);
995 }
115329f1 996
1008ceb3
MN
997 if (is_last_report && verbose >= 0){
998 int64_t raw= audio_size + video_size + extra_size;
f068206e 999 fprintf(stderr, "\n");
1008ceb3
MN
1000 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1001 video_size/1024.0,
1002 audio_size/1024.0,
1003 extra_size/1024.0,
1004 100.0*(total_size - raw)/raw
1005 );
1006 }
ce7c56c2
J
1007}
1008
a700a6ae
FB
1009/* pkt = NULL means EOF (needed to flush decoder buffers) */
1010static int output_packet(AVInputStream *ist, int ist_index,
1011 AVOutputStream **ost_table, int nb_ostreams,
4b85a28f 1012 const AVPacket *pkt)
a700a6ae
FB
1013{
1014 AVFormatContext *os;
1015 AVOutputStream *ost;
1016 uint8_t *ptr;
1017 int len, ret, i;
1018 uint8_t *data_buf;
1019 int data_size, got_picture;
1020 AVFrame picture;
a700a6ae 1021 void *buffer_to_free;
f038fe8b 1022 static unsigned int samples_size= 0;
78953e62 1023 static short *samples= NULL;
cf7fc795
FB
1024 AVSubtitle subtitle, *subtitle_to_free;
1025 int got_subtitle;
115329f1 1026
2b18dcd0
MN
1027 if(!pkt){
1028 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1029 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
c0df9d75 1030 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
a700a6ae 1031 } else {
a603bf8d 1032// assert(ist->pts == ist->next_pts);
a700a6ae 1033 }
115329f1 1034
a700a6ae
FB
1035 if (pkt == NULL) {
1036 /* EOF handling */
1037 ptr = NULL;
1038 len = 0;
1039 goto handle_eof;
1040 }
1041
1042 len = pkt->size;
1043 ptr = pkt->data;
1044 while (len > 0) {
1045 handle_eof:
1046 /* decode the packet if needed */
1047 data_buf = NULL; /* fail safe */
1048 data_size = 0;
cf7fc795 1049 subtitle_to_free = NULL;
a700a6ae 1050 if (ist->decoding_needed) {
01f4895c 1051 switch(ist->st->codec->codec_type) {
df84ac2e 1052 case CODEC_TYPE_AUDIO:{
115329f1 1053 if(pkt)
78953e62 1054 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
5d55e966 1055 data_size= samples_size;
a700a6ae
FB
1056 /* XXX: could avoid copy if PCM 16 bits with same
1057 endianness as CPU */
5d55e966 1058 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
a700a6ae
FB
1059 ptr, len);
1060 if (ret < 0)
1061 goto fail_decode;
1062 ptr += ret;
1063 len -= ret;
1064 /* Some bug in mpeg audio decoder gives */
1065 /* data_size < 0, it seems they are overflows */
1066 if (data_size <= 0) {
1067 /* no audio frame */
1068 continue;
1069 }
1070 data_buf = (uint8_t *)samples;
115329f1 1071 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
01f4895c 1072 (ist->st->codec->sample_rate * ist->st->codec->channels);
df84ac2e 1073 break;}
a700a6ae 1074 case CODEC_TYPE_VIDEO:
01f4895c 1075 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
a700a6ae 1076 /* XXX: allocate picture correctly */
9740beff
MN
1077 avcodec_get_frame_defaults(&picture);
1078
115329f1 1079 ret = avcodec_decode_video(ist->st->codec,
a700a6ae
FB
1080 &picture, &got_picture, ptr, len);
1081 ist->st->quality= picture.quality;
115329f1 1082 if (ret < 0)
a700a6ae
FB
1083 goto fail_decode;
1084 if (!got_picture) {
1085 /* no picture yet */
1086 goto discard_packet;
1087 }
01f4895c 1088 if (ist->st->codec->time_base.num != 0) {
115329f1 1089 ist->next_pts += ((int64_t)AV_TIME_BASE *
01f4895c
MN
1090 ist->st->codec->time_base.num) /
1091 ist->st->codec->time_base.den;
a700a6ae
FB
1092 }
1093 len = 0;
1094 break;
cf7fc795 1095 case CODEC_TYPE_SUBTITLE:
115329f1 1096 ret = avcodec_decode_subtitle(ist->st->codec,
cf7fc795
FB
1097 &subtitle, &got_subtitle, ptr, len);
1098 if (ret < 0)
a700a6ae 1099 goto fail_decode;
cf7fc795
FB
1100 if (!got_subtitle) {
1101 goto discard_packet;
a700a6ae 1102 }
cf7fc795
FB
1103 subtitle_to_free = &subtitle;
1104 len = 0;
1105 break;
1106 default:
1107 goto fail_decode;
1108 }
1109 } else {
01f4895c 1110 switch(ist->st->codec->codec_type) {
2fef0bdf 1111 case CODEC_TYPE_AUDIO:
115329f1 1112 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
01f4895c 1113 (ist->st->codec->sample_rate * ist->st->codec->channels);
2fef0bdf
MN
1114 break;
1115 case CODEC_TYPE_VIDEO:
01f4895c 1116 if (ist->st->codec->time_base.num != 0) {
115329f1 1117 ist->next_pts += ((int64_t)AV_TIME_BASE *
01f4895c
MN
1118 ist->st->codec->time_base.num) /
1119 ist->st->codec->time_base.den;
2fef0bdf
MN
1120 }
1121 break;
1122 }
a700a6ae
FB
1123 data_buf = ptr;
1124 data_size = len;
1125 ret = len;
1126 len = 0;
1127 }
1128
1129 buffer_to_free = NULL;
01f4895c 1130 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
115329f1 1131 pre_process_video_frame(ist, (AVPicture *)&picture,
a700a6ae
FB
1132 &buffer_to_free);
1133 }
1134
7e987c33 1135 // preprocess audio (volume)
01f4895c 1136 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
a9aa3467 1137 if (audio_volume != 256) {
7e987c33 1138 short *volp;
7e987c33
C
1139 volp = samples;
1140 for(i=0;i<(data_size / sizeof(short));i++) {
a9aa3467 1141 int v = ((*volp) * audio_volume + 128) >> 8;
7e987c33
C
1142 if (v < -32768) v = -32768;
1143 if (v > 32767) v = 32767;
1144 *volp++ = v;
1145 }
1146 }
1147 }
1148
a700a6ae 1149 /* frame rate emulation */
01f4895c
MN
1150 if (ist->st->codec->rate_emu) {
1151 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
a700a6ae
FB
1152 int64_t now = av_gettime() - ist->start;
1153 if (pts > now)
1154 usleep(pts - now);
1155
1156 ist->frame++;
1157 }
1158
1159#if 0
1160 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1161 is the one of the next displayed one */
1162 /* XXX: add mpeg4 too ? */
01f4895c
MN
1163 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1164 if (ist->st->codec->pict_type != B_TYPE) {
a700a6ae
FB
1165 int64_t tmp;
1166 tmp = ist->last_ip_pts;
1167 ist->last_ip_pts = ist->frac_pts.val;
1168 ist->frac_pts.val = tmp;
1169 }
1170 }
1171#endif
115329f1 1172 /* if output time reached then transcode raw format,
bb270c08 1173 encode packets and output them */
a700a6ae
FB
1174 if (start_time == 0 || ist->pts >= start_time)
1175 for(i=0;i<nb_ostreams;i++) {
1176 int frame_size;
1177
1178 ost = ost_table[i];
1179 if (ost->source_index == ist_index) {
1180 os = output_files[ost->file_index];
1181
1182#if 0
115329f1
DB
1183 printf("%d: got pts=%0.3f %0.3f\n", i,
1184 (double)pkt->pts / AV_TIME_BASE,
1185 ((double)ist->pts / AV_TIME_BASE) -
986ebcdb 1186 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
a700a6ae
FB
1187#endif
1188 /* set the input output pts pairs */
b4a3389e 1189 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
a700a6ae
FB
1190
1191 if (ost->encoding_needed) {
01f4895c 1192 switch(ost->st->codec->codec_type) {
a700a6ae
FB
1193 case CODEC_TYPE_AUDIO:
1194 do_audio_out(os, ost, ist, data_buf, data_size);
1195 break;
1196 case CODEC_TYPE_VIDEO:
986ebcdb 1197 do_video_out(os, ost, ist, &picture, &frame_size);
1008ceb3 1198 video_size += frame_size;
a700a6ae
FB
1199 if (do_vstats && frame_size)
1200 do_video_stats(os, ost, frame_size);
a700a6ae 1201 break;
cf7fc795
FB
1202 case CODEC_TYPE_SUBTITLE:
1203 do_subtitle_out(os, ost, ist, &subtitle,
1204 pkt->pts);
1205 break;
a700a6ae
FB
1206 default:
1207 av_abort();
1208 }
1209 } else {
e928649b
MN
1210 AVFrame avframe; //FIXME/XXX remove this
1211 AVPacket opkt;
1212 av_init_packet(&opkt);
1213
a700a6ae
FB
1214 /* no reencoding needed : output the packet directly */
1215 /* force the input stream PTS */
115329f1 1216
9740beff 1217 avcodec_get_frame_defaults(&avframe);
01f4895c 1218 ost->st->codec->coded_frame= &avframe;
115329f1 1219 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
bf17ff61 1220
01f4895c 1221 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
c7baf14b 1222 audio_size += data_size;
01f4895c 1223 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
c7baf14b 1224 video_size += data_size;
daed32f7
WG
1225 ost->sync_opts++;
1226 }
c7baf14b 1227
e928649b 1228 opkt.stream_index= ost->index;
6c55b27f 1229 if(pkt->pts != AV_NOPTS_VALUE)
c0df9d75 1230 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
6c55b27f
MN
1231 else
1232 opkt.pts= AV_NOPTS_VALUE;
cf7fc795
FB
1233
1234 {
1235 int64_t dts;
1236 if (pkt->dts == AV_NOPTS_VALUE)
1237 dts = ist->next_pts;
1238 else
1239 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1240 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1241 }
e928649b 1242 opkt.flags= pkt->flags;
748c2fca
MN
1243
1244 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
01f4895c 1245 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
90ad92b3 1246 opkt.destruct= av_destruct_packet;
748c2fca
MN
1247
1248 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
01f4895c 1249 ost->st->codec->frame_number++;
a700a6ae 1250 ost->frame_number++;
90ad92b3 1251 av_free_packet(&opkt);
a700a6ae
FB
1252 }
1253 }
1254 }
1255 av_free(buffer_to_free);
cf7fc795
FB
1256 /* XXX: allocate the subtitles in the codec ? */
1257 if (subtitle_to_free) {
c6ec28b1
MN
1258 if (subtitle_to_free->rects != NULL) {
1259 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1260 av_free(subtitle_to_free->rects[i].bitmap);
1261 av_free(subtitle_to_free->rects[i].rgba_palette);
1262 }
1263 av_freep(&subtitle_to_free->rects);
1264 }
1265 subtitle_to_free->num_rects = 0;
cf7fc795
FB
1266 subtitle_to_free = NULL;
1267 }
a700a6ae
FB
1268 }
1269 discard_packet:
6f824977
MN
1270 if (pkt == NULL) {
1271 /* EOF handling */
115329f1 1272
6f824977
MN
1273 for(i=0;i<nb_ostreams;i++) {
1274 ost = ost_table[i];
1275 if (ost->source_index == ist_index) {
01f4895c 1276 AVCodecContext *enc= ost->st->codec;
6f824977 1277 os = output_files[ost->file_index];
115329f1 1278
01f4895c 1279 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
6f824977 1280 continue;
01f4895c 1281 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
6f824977
MN
1282 continue;
1283
1284 if (ost->encoding_needed) {
1285 for(;;) {
1286 AVPacket pkt;
cef7cc72 1287 int fifo_bytes;
6f824977
MN
1288 av_init_packet(&pkt);
1289 pkt.stream_index= ost->index;
115329f1 1290
01f4895c 1291 switch(ost->st->codec->codec_type) {
115329f1 1292 case CODEC_TYPE_AUDIO:
f5a478f6 1293 fifo_bytes = av_fifo_size(&ost->fifo);
cef7cc72
JR
1294 ret = 0;
1295 /* encode any samples remaining in fifo */
1296 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1297 int fs_tmp = enc->frame_size;
1298 enc->frame_size = fifo_bytes / (2 * enc->channels);
f5a478f6 1299 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
cef7cc72
JR
1300 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1301 }
1302 enc->frame_size = fs_tmp;
9e0db7d5
MN
1303 }
1304 if(ret <= 0) {
cef7cc72
JR
1305 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1306 }
6f824977
MN
1307 audio_size += ret;
1308 pkt.flags |= PKT_FLAG_KEY;
1309 break;
1310 case CODEC_TYPE_VIDEO:
8a6cb114 1311 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
6f824977
MN
1312 video_size += ret;
1313 if(enc->coded_frame && enc->coded_frame->key_frame)
1314 pkt.flags |= PKT_FLAG_KEY;
1315 if (ost->logfile && enc->stats_out) {
1316 fprintf(ost->logfile, "%s", enc->stats_out);
1317 }
1318 break;
1319 default:
1320 ret=-1;
1321 }
115329f1 1322
6f824977
MN
1323 if(ret<=0)
1324 break;
27537106 1325 pkt.data= bit_buffer;
6f824977 1326 pkt.size= ret;
e7902f20 1327 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
c0df9d75 1328 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
748c2fca 1329 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
6f824977
MN
1330 }
1331 }
1332 }
1333 }
1334 }
115329f1 1335
a700a6ae
FB
1336 return 0;
1337 fail_decode:
1338 return -1;
1339}
1340
1341
85f07f22
FB
1342/*
1343 * The following code is the main loop of the file converter
1344 */
1345static int av_encode(AVFormatContext **output_files,
1346 int nb_output_files,
1347 AVFormatContext **input_files,
1348 int nb_input_files,
1349 AVStreamMap *stream_maps, int nb_stream_maps)
1350{
445f1b83 1351 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
85f07f22
FB
1352 AVFormatContext *is, *os;
1353 AVCodecContext *codec, *icodec;
1354 AVOutputStream *ost, **ost_table = NULL;
1355 AVInputStream *ist, **ist_table = NULL;
bdc4796f 1356 AVInputFile *file_table;
51bd4565 1357 AVFormatContext *stream_no_data;
cb09b2ed 1358 int key;
bdc4796f 1359
51bd4565 1360 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
bdc4796f
FB
1361 if (!file_table)
1362 goto fail;
115329f1 1363
85f07f22
FB
1364 /* input stream init */
1365 j = 0;
1366 for(i=0;i<nb_input_files;i++) {
1367 is = input_files[i];
1368 file_table[i].ist_index = j;
79fdaa4c 1369 file_table[i].nb_streams = is->nb_streams;
85f07f22
FB
1370 j += is->nb_streams;
1371 }
1372 nb_istreams = j;
1373
1374 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1375 if (!ist_table)
bdc4796f 1376 goto fail;
115329f1 1377
85f07f22
FB
1378 for(i=0;i<nb_istreams;i++) {
1379 ist = av_mallocz(sizeof(AVInputStream));
1380 if (!ist)
1381 goto fail;
1382 ist_table[i] = ist;
1383 }
1384 j = 0;
1385 for(i=0;i<nb_input_files;i++) {
1386 is = input_files[i];
1387 for(k=0;k<is->nb_streams;k++) {
1388 ist = ist_table[j++];
1389 ist->st = is->streams[k];
1390 ist->file_index = i;
1391 ist->index = k;
1392 ist->discard = 1; /* the stream is discarded by default
1393 (changed later) */
bdfcbbed 1394
01f4895c 1395 if (ist->st->codec->rate_emu) {
bdfcbbed
MK
1396 ist->start = av_gettime();
1397 ist->frame = 0;
1398 }
85f07f22
FB
1399 }
1400 }
1401
1402 /* output stream init */
1403 nb_ostreams = 0;
1404 for(i=0;i<nb_output_files;i++) {
1405 os = output_files[i];
8a7bde1c
BC
1406 if (!os->nb_streams) {
1407 fprintf(stderr, "Output file does not contain any stream\n");
1408 exit(1);
1409 }
85f07f22
FB
1410 nb_ostreams += os->nb_streams;
1411 }
1412 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1413 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1414 exit(1);
1415 }
1416
bd073980
BF
1417 /* Sanity check the mapping args -- do the input files & streams exist? */
1418 for(i=0;i<nb_stream_maps;i++) {
1419 int fi = stream_maps[i].file_index;
1420 int si = stream_maps[i].stream_index;
115329f1 1421
bd073980
BF
1422 if (fi < 0 || fi > nb_input_files - 1 ||
1423 si < 0 || si > file_table[fi].nb_streams - 1) {
1424 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1425 exit(1);
1426 }
b4a3389e
WG
1427 fi = stream_maps[i].sync_file_index;
1428 si = stream_maps[i].sync_stream_index;
1429 if (fi < 0 || fi > nb_input_files - 1 ||
1430 si < 0 || si > file_table[fi].nb_streams - 1) {
1431 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1432 exit(1);
1433 }
bd073980 1434 }
115329f1 1435
85f07f22
FB
1436 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1437 if (!ost_table)
1438 goto fail;
1439 for(i=0;i<nb_ostreams;i++) {
1440 ost = av_mallocz(sizeof(AVOutputStream));
1441 if (!ost)
1442 goto fail;
1443 ost_table[i] = ost;
1444 }
115329f1 1445
85f07f22
FB
1446 n = 0;
1447 for(k=0;k<nb_output_files;k++) {
1448 os = output_files[k];
1449 for(i=0;i<os->nb_streams;i++) {
1450 int found;
1451 ost = ost_table[n++];
1452 ost->file_index = k;
1453 ost->index = i;
1454 ost->st = os->streams[i];
1455 if (nb_stream_maps > 0) {
115329f1 1456 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
85f07f22 1457 stream_maps[n-1].stream_index;
115329f1 1458
bd073980 1459 /* Sanity check that the stream types match */
01f4895c 1460 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
bd073980
BF
1461 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1462 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1463 ost->file_index, ost->index);
1464 exit(1);
1465 }
115329f1 1466
85f07f22
FB
1467 } else {
1468 /* get corresponding input stream index : we select the first one with the right type */
1469 found = 0;
1470 for(j=0;j<nb_istreams;j++) {
1471 ist = ist_table[j];
115329f1 1472 if (ist->discard &&
01f4895c 1473 ist->st->codec->codec_type == ost->st->codec->codec_type) {
85f07f22
FB
1474 ost->source_index = j;
1475 found = 1;
c19e76ce 1476 break;
85f07f22
FB
1477 }
1478 }
115329f1 1479
85f07f22
FB
1480 if (!found) {
1481 /* try again and reuse existing stream */
1482 for(j=0;j<nb_istreams;j++) {
1483 ist = ist_table[j];
01f4895c 1484 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
85f07f22
FB
1485 ost->source_index = j;
1486 found = 1;
1487 }
1488 }
1489 if (!found) {
1490 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1491 ost->file_index, ost->index);
1492 exit(1);
1493 }
1494 }
1495 }
1496 ist = ist_table[ost->source_index];
1497 ist->discard = 0;
b4a3389e
WG
1498 ost->sync_ist = (nb_stream_maps > 0) ?
1499 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1500 stream_maps[n-1].sync_stream_index] : ist;
85f07f22
FB
1501 }
1502 }
1503
85f07f22
FB
1504 /* for each output stream, we compute the right encoding parameters */
1505 for(i=0;i<nb_ostreams;i++) {
1506 ost = ost_table[i];
1507 ist = ist_table[ost->source_index];
1508
01f4895c
MN
1509 codec = ost->st->codec;
1510 icodec = ist->st->codec;
85f07f22 1511
1629626f
FB
1512 if (ost->st->stream_copy) {
1513 /* if stream_copy is selected, no need to decode or encode */
1514 codec->codec_id = icodec->codec_id;
1515 codec->codec_type = icodec->codec_type;
b2a2197e 1516 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1629626f 1517 codec->bit_rate = icodec->bit_rate;
dffbfd06
MN
1518 codec->extradata= icodec->extradata;
1519 codec->extradata_size= icodec->extradata_size;
4408e75e 1520 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
d29de719
MN
1521 codec->time_base = icodec->time_base;
1522 else
1523 codec->time_base = ist->st->time_base;
1629626f
FB
1524 switch(codec->codec_type) {
1525 case CODEC_TYPE_AUDIO:
1526 codec->sample_rate = icodec->sample_rate;
1527 codec->channels = icodec->channels;
0a3b0447 1528 codec->frame_size = icodec->frame_size;
c1344911 1529 codec->block_align= icodec->block_align;
1629626f
FB
1530 break;
1531 case CODEC_TYPE_VIDEO:
8d74e55b
MD
1532 if(using_vhook) {
1533 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1534 exit(1);
1535 }
9df3437f 1536 codec->pix_fmt = icodec->pix_fmt;
1629626f
FB
1537 codec->width = icodec->width;
1538 codec->height = icodec->height;
ff8cc24b 1539 codec->has_b_frames = icodec->has_b_frames;
1629626f 1540 break;
cf7fc795
FB
1541 case CODEC_TYPE_SUBTITLE:
1542 break;
1629626f
FB
1543 default:
1544 av_abort();
1545 }
1546 } else {
1547 switch(codec->codec_type) {
1548 case CODEC_TYPE_AUDIO:
f5a478f6 1549 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
85f07f22 1550 goto fail;
115329f1 1551
85f07f22
FB
1552 if (codec->channels == icodec->channels &&
1553 codec->sample_rate == icodec->sample_rate) {
1554 ost->audio_resample = 0;
1555 } else {
e0d2714a 1556 if (codec->channels != icodec->channels &&
23c99253
MN
1557 (icodec->codec_id == CODEC_ID_AC3 ||
1558 icodec->codec_id == CODEC_ID_DTS)) {
1559 /* Special case for 5:1 AC3 and DTS input */
e0d2714a 1560 /* and mono or stereo output */
6dc96cb0
J
1561 /* Request specific number of channels */
1562 icodec->channels = codec->channels;
1563 if (codec->sample_rate == icodec->sample_rate)
1564 ost->audio_resample = 0;
1565 else {
1566 ost->audio_resample = 1;
6dc96cb0 1567 }
e0d2714a 1568 } else {
115329f1 1569 ost->audio_resample = 1;
986ebcdb
MN
1570 }
1571 }
ff4905a5 1572 if(audio_sync_method>1)
986ebcdb
MN
1573 ost->audio_resample = 1;
1574
1575 if(ost->audio_resample){
1576 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1577 codec->sample_rate, icodec->sample_rate);
1578 if(!ost->resample){
1579 printf("Can't resample. Aborting.\n");
1580 av_abort();
e0d2714a 1581 }
85f07f22
FB
1582 }
1583 ist->decoding_needed = 1;
1584 ost->encoding_needed = 1;
1629626f
FB
1585 break;
1586 case CODEC_TYPE_VIDEO:
c3f11d19
LA
1587 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1588 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1589 ost->video_resample = ((codec->width != icodec->width -
1590 (frame_leftBand + frame_rightBand) +
1591 (frame_padleft + frame_padright)) ||
1592 (codec->height != icodec->height -
1593 (frame_topBand + frame_bottomBand) +
18a54b04
LA
1594 (frame_padtop + frame_padbottom)) ||
1595 (codec->pix_fmt != icodec->pix_fmt));
c3f11d19 1596 if (ost->video_crop) {
34b10a57
D
1597 ost->topBand = frame_topBand;
1598 ost->leftBand = frame_leftBand;
c3f11d19
LA
1599 }
1600 if (ost->video_pad) {
1ff93ffc
TK
1601 ost->padtop = frame_padtop;
1602 ost->padleft = frame_padleft;
1603 ost->padbottom = frame_padbottom;
1604 ost->padright = frame_padright;
c3f11d19
LA
1605 if (!ost->video_resample) {
1606 avcodec_get_frame_defaults(&ost->pict_tmp);
1607 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1608 codec->width, codec->height ) )
1609 goto fail;
1610 }
1611 }
1612 if (ost->video_resample) {
2de28abb 1613 avcodec_get_frame_defaults(&ost->pict_tmp);
18a54b04 1614 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2caa92d9 1615 codec->width, codec->height ) )
7a168618 1616 exit(1);
85f07f22 1617
18a54b04
LA
1618 ost->img_resample_ctx = sws_getContext(
1619 icodec->width - (frame_leftBand + frame_rightBand),
1620 icodec->height - (frame_topBand + frame_bottomBand),
1621 icodec->pix_fmt,
07d0cdfc
LA
1622 codec->width - (frame_padleft + frame_padright),
1623 codec->height - (frame_padtop + frame_padbottom),
18a54b04
LA
1624 codec->pix_fmt,
1625 sws_flags, NULL, NULL, NULL);
0b50ac8a
LA
1626 if (ost->img_resample_ctx == NULL) {
1627 fprintf(stderr, "Cannot get resampling context\n");
1628 exit(1);
1629 }
18a54b04 1630 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
85f07f22
FB
1631 }
1632 ost->encoding_needed = 1;
1633 ist->decoding_needed = 1;
1629626f 1634 break;
cf7fc795
FB
1635 case CODEC_TYPE_SUBTITLE:
1636 ost->encoding_needed = 1;
1637 ist->decoding_needed = 1;
1638 break;
1629626f
FB
1639 default:
1640 av_abort();
cf7fc795 1641 break;
85f07f22 1642 }
1629626f 1643 /* two pass mode */
115329f1 1644 if (ost->encoding_needed &&
1629626f
FB
1645 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1646 char logfilename[1024];
1647 FILE *f;
1648 int size;
1649 char *logbuffer;
115329f1
DB
1650
1651 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1652 pass_logfilename ?
1629626f
FB
1653 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1654 if (codec->flags & CODEC_FLAG_PASS1) {
1655 f = fopen(logfilename, "w");
1656 if (!f) {
1657 perror(logfilename);
1658 exit(1);
1659 }
1660 ost->logfile = f;
1661 } else {
1662 /* read the log file */
1663 f = fopen(logfilename, "r");
1664 if (!f) {
1665 perror(logfilename);
1666 exit(1);
1667 }
1668 fseek(f, 0, SEEK_END);
1669 size = ftell(f);
1670 fseek(f, 0, SEEK_SET);
1671 logbuffer = av_malloc(size + 1);
1672 if (!logbuffer) {
1673 fprintf(stderr, "Could not allocate log buffer\n");
1674 exit(1);
1675 }
4776fa92 1676 size = fread(logbuffer, 1, size, f);
1629626f
FB
1677 fclose(f);
1678 logbuffer[size] = '\0';
1679 codec->stats_in = logbuffer;
5abdb4b1 1680 }
5abdb4b1
FB
1681 }
1682 }
8a6cb114
MN
1683 if(codec->codec_type == CODEC_TYPE_VIDEO){
1684 int size= codec->width * codec->height;
1685 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1686 }
85f07f22
FB
1687 }
1688
8a6cb114
MN
1689 if (!bit_buffer)
1690 bit_buffer = av_malloc(bit_buffer_size);
1691 if (!bit_buffer)
1692 goto fail;
1693
1629626f
FB
1694 /* dump the file output parameters - cannot be done before in case
1695 of stream copy */
1696 for(i=0;i<nb_output_files;i++) {
1697 dump_format(output_files[i], i, output_files[i]->filename, 1);
1698 }
1699
1700 /* dump the stream mapping */
d8019eb5
AD
1701 if (verbose >= 0) {
1702 fprintf(stderr, "Stream mapping:\n");
1703 for(i=0;i<nb_ostreams;i++) {
1704 ost = ost_table[i];
b4a3389e 1705 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
d8019eb5
AD
1706 ist_table[ost->source_index]->file_index,
1707 ist_table[ost->source_index]->index,
115329f1 1708 ost->file_index,
d8019eb5 1709 ost->index);
b4a3389e
WG
1710 if (ost->sync_ist != ist_table[ost->source_index])
1711 fprintf(stderr, " [sync #%d.%d]",
1712 ost->sync_ist->file_index,
1713 ost->sync_ist->index);
1714 fprintf(stderr, "\n");
d8019eb5 1715 }
1629626f
FB
1716 }
1717
85f07f22
FB
1718 /* open each encoder */
1719 for(i=0;i<nb_ostreams;i++) {
1720 ost = ost_table[i];
1721 if (ost->encoding_needed) {
1722 AVCodec *codec;
01f4895c 1723 codec = avcodec_find_encoder(ost->st->codec->codec_id);
85f07f22 1724 if (!codec) {
115329f1 1725 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
85f07f22
FB
1726 ost->file_index, ost->index);
1727 exit(1);
1728 }
01f4895c 1729 if (avcodec_open(ost->st->codec, codec) < 0) {
115329f1 1730 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
85f07f22
FB
1731 ost->file_index, ost->index);
1732 exit(1);
1733 }
01f4895c 1734 extra_size += ost->st->codec->extradata_size;
85f07f22
FB
1735 }
1736 }
1737
1738 /* open each decoder */
1739 for(i=0;i<nb_istreams;i++) {
1740 ist = ist_table[i];
1741 if (ist->decoding_needed) {
1742 AVCodec *codec;
01f4895c 1743 codec = avcodec_find_decoder(ist->st->codec->codec_id);
85f07f22 1744 if (!codec) {
115329f1 1745 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
01f4895c 1746 ist->st->codec->codec_id, ist->file_index, ist->index);
85f07f22
FB
1747 exit(1);
1748 }
01f4895c 1749 if (avcodec_open(ist->st->codec, codec) < 0) {
115329f1 1750 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
85f07f22
FB
1751 ist->file_index, ist->index);
1752 exit(1);
1753 }
01f4895c
MN
1754 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1755 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
85f07f22
FB
1756 }
1757 }
1758
1759 /* init pts */
1760 for(i=0;i<nb_istreams;i++) {
1761 ist = ist_table[i];
bb270c08 1762 is = input_files[ist->file_index];
e7d0374f 1763 ist->pts = 0;
c0df9d75 1764 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
115329f1 1765 if(ist->st->start_time == AV_NOPTS_VALUE)
bd1b79a1 1766 ist->next_pts=0;
fdb86eb1
MN
1767 if(input_files_ts_offset[ist->file_index])
1768 ist->next_pts= AV_NOPTS_VALUE;
ff4905a5 1769 ist->is_start = 1;
85f07f22 1770 }
bd1b79a1 1771
85f07f22
FB
1772 /* compute buffer size max (should use a complete heuristic) */
1773 for(i=0;i<nb_input_files;i++) {
1774 file_table[i].buffer_size_max = 2048;
1775 }
1776
0a38bafd
PB
1777 /* set meta data information from input file if required */
1778 for (i=0;i<nb_meta_data_maps;i++) {
1779 AVFormatContext *out_file;
1780 AVFormatContext *in_file;
1781
1782 int out_file_index = meta_data_maps[i].out_file;
1783 int in_file_index = meta_data_maps[i].in_file;
1784 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1785 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
8fa36ae0 1786 ret = AVERROR(EINVAL);
0a38bafd
PB
1787 goto fail;
1788 }
1789 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1790 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
8fa36ae0 1791 ret = AVERROR(EINVAL);
0a38bafd 1792 goto fail;
115329f1
DB
1793 }
1794
0a38bafd
PB
1795 out_file = output_files[out_file_index];
1796 in_file = input_files[in_file_index];
1797
1798 strcpy(out_file->title, in_file->title);
1799 strcpy(out_file->author, in_file->author);
1800 strcpy(out_file->copyright, in_file->copyright);
1801 strcpy(out_file->comment, in_file->comment);
1802 strcpy(out_file->album, in_file->album);
1803 out_file->year = in_file->year;
1804 out_file->track = in_file->track;
1805 strcpy(out_file->genre, in_file->genre);
1806 }
115329f1 1807
85f07f22
FB
1808 /* open files and write file headers */
1809 for(i=0;i<nb_output_files;i++) {
1810 os = output_files[i];
79fdaa4c 1811 if (av_write_header(os) < 0) {
65bf3c53 1812 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
8fa36ae0 1813 ret = AVERROR(EINVAL);
a38469e1
FB
1814 goto fail;
1815 }
85f07f22
FB
1816 }
1817
d8019eb5 1818 if ( !using_stdin && verbose >= 0) {
d9a916e2 1819 fprintf(stderr, "Press [q] to stop encoding\n");
b51469a0
LS
1820 url_set_interrupt_cb(decode_interrupt_cb);
1821 }
a38469e1
FB
1822 term_init();
1823
51bd4565 1824 stream_no_data = 0;
cb09b2ed 1825 key = -1;
51bd4565 1826
d9a916e2 1827 for(; received_sigterm == 0;) {
85f07f22
FB
1828 int file_index, ist_index;
1829 AVPacket pkt;
a9aeda81
PB
1830 double ipts_min;
1831 double opts_min;
23ffe323 1832
85f07f22 1833 redo:
a9aeda81
PB
1834 ipts_min= 1e100;
1835 opts_min= 1e100;
a38469e1 1836 /* if 'q' pressed, exits */
d9a916e2 1837 if (!using_stdin) {
b51469a0
LS
1838 if (q_pressed)
1839 break;
cb09b2ed
PG
1840 /* read_key() returns 0 on EOF */
1841 key = read_key();
1842 if (key == 'q')
1843 break;
1844 }
a38469e1 1845
ec5517d5
FB
1846 /* select the stream that we must read now by looking at the
1847 smallest output pts */
85f07f22 1848 file_index = -1;
ec5517d5 1849 for(i=0;i<nb_ostreams;i++) {
23ffe323 1850 double ipts, opts;
ec5517d5
FB
1851 ost = ost_table[i];
1852 os = output_files[ost->file_index];
1853 ist = ist_table[ost->source_index];
01f4895c
MN
1854 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1855 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
23ffe323 1856 else
c0df9d75 1857 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
23ffe323
MN
1858 ipts = (double)ist->pts;
1859 if (!file_table[ist->file_index].eof_reached){
1860 if(ipts < ipts_min) {
1861 ipts_min = ipts;
1862 if(input_sync ) file_index = ist->file_index;
1863 }
1864 if(opts < opts_min) {
1865 opts_min = opts;
1866 if(!input_sync) file_index = ist->file_index;
1867 }
85f07f22 1868 }
01f4895c 1869 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
7ca60994
MN
1870 file_index= -1;
1871 break;
1872 }
85f07f22
FB
1873 }
1874 /* if none, if is finished */
51bd4565 1875 if (file_index < 0) {
85f07f22 1876 break;
ec5517d5
FB
1877 }
1878
85f07f22 1879 /* finish if recording time exhausted */
23ffe323 1880 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
85f07f22 1881 break;
ec5517d5 1882
b6e16b86
C
1883 /* finish if limit size exhausted */
1884 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1885 break;
1886
254abc2e 1887 /* read a frame from it and output it in the fifo */
85f07f22 1888 is = input_files[file_index];
254abc2e 1889 if (av_read_frame(is, &pkt) < 0) {
85f07f22 1890 file_table[file_index].eof_reached = 1;
ca80810b 1891 if (opt_shortest) break; else continue; //
85f07f22 1892 }
303e50e6 1893
51bd4565
PG
1894 if (!pkt.size) {
1895 stream_no_data = is;
1896 } else {
1897 stream_no_data = 0;
1898 }
254abc2e
FB
1899 if (do_pkt_dump) {
1900 av_pkt_dump(stdout, &pkt, do_hex_dump);
817b23ff 1901 }
79fdaa4c
FB
1902 /* the following test is needed in case new streams appear
1903 dynamically in stream : we ignore them */
1904 if (pkt.stream_index >= file_table[file_index].nb_streams)
bf5af568 1905 goto discard_packet;
85f07f22
FB
1906 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1907 ist = ist_table[ist_index];
bf5af568
FB
1908 if (ist->discard)
1909 goto discard_packet;
85f07f22 1910
949b1a13 1911// fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
fdb86eb1 1912 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
c0df9d75 1913 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
c26abfa5 1914 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
72bd8100
MN
1915 input_files_ts_offset[ist->file_index]-= delta;
1916 if (verbose > 2)
4733abcb 1917 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
72bd8100
MN
1918 for(i=0; i<file_table[file_index].nb_streams; i++){
1919 int index= file_table[file_index].ist_index + i;
1920 ist_table[index]->next_pts += delta;
ff4905a5 1921 ist_table[index]->is_start=1;
72bd8100
MN
1922 }
1923 }
1924 }
1925
8831db5c 1926 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
a700a6ae 1927 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
d8019eb5
AD
1928
1929 if (verbose >= 0)
1930 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1931 ist->file_index, ist->index);
1932
a700a6ae
FB
1933 av_free_packet(&pkt);
1934 goto redo;
fe08925f 1935 }
cf7fc795 1936
bf5af568 1937 discard_packet:
85f07f22 1938 av_free_packet(&pkt);
115329f1 1939
ec5517d5
FB
1940 /* dump report by using the output first video and audio streams */
1941 print_report(output_files, ost_table, nb_ostreams, 0);
85f07f22 1942 }
a700a6ae
FB
1943
1944 /* at the end of stream, we must flush the decoder buffers */
1945 for(i=0;i<nb_istreams;i++) {
1946 ist = ist_table[i];
1947 if (ist->decoding_needed) {
1948 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1949 }
1950 }
1951
a38469e1 1952 term_exit();
85f07f22 1953
c4e37247
MN
1954 /* write the trailer if needed and close file */
1955 for(i=0;i<nb_output_files;i++) {
1956 os = output_files[i];
1957 av_write_trailer(os);
1958 }
1959
37f5cd5a
MN
1960 /* dump report by using the first video and audio streams */
1961 print_report(output_files, ost_table, nb_ostreams, 1);
1962
85f07f22
FB
1963 /* close each encoder */
1964 for(i=0;i<nb_ostreams;i++) {
1965 ost = ost_table[i];
1966 if (ost->encoding_needed) {
01f4895c
MN
1967 av_freep(&ost->st->codec->stats_in);
1968 avcodec_close(ost->st->codec);
85f07f22
FB
1969 }
1970 }
115329f1 1971
85f07f22
FB
1972 /* close each decoder */
1973 for(i=0;i<nb_istreams;i++) {
1974 ist = ist_table[i];
1975 if (ist->decoding_needed) {
01f4895c 1976 avcodec_close(ist->st->codec);
85f07f22
FB
1977 }
1978 }
85f07f22 1979
85f07f22 1980 /* finished ! */
115329f1 1981
85f07f22
FB
1982 ret = 0;
1983 fail1:
83b07470 1984 av_freep(&bit_buffer);
0f1578af 1985 av_free(file_table);
bdc4796f 1986
85f07f22
FB
1987 if (ist_table) {
1988 for(i=0;i<nb_istreams;i++) {
1989 ist = ist_table[i];
0f1578af 1990 av_free(ist);
85f07f22 1991 }
0f1578af 1992 av_free(ist_table);
85f07f22
FB
1993 }
1994 if (ost_table) {
1995 for(i=0;i<nb_ostreams;i++) {
1996 ost = ost_table[i];
1997 if (ost) {
5abdb4b1
FB
1998 if (ost->logfile) {
1999 fclose(ost->logfile);
2000 ost->logfile = NULL;
2001 }
f5a478f6
RS
2002 av_fifo_free(&ost->fifo); /* works even if fifo is not
2003 initialized but set to zero */
0f1578af 2004 av_free(ost->pict_tmp.data[0]);
85f07f22 2005 if (ost->video_resample)
18a54b04 2006 sws_freeContext(ost->img_resample_ctx);
85f07f22
FB
2007 if (ost->audio_resample)
2008 audio_resample_close(ost->resample);
0f1578af 2009 av_free(ost);
85f07f22
FB
2010 }
2011 }
0f1578af 2012 av_free(ost_table);
85f07f22
FB
2013 }
2014 return ret;
2015 fail:
8fa36ae0 2016 ret = AVERROR(ENOMEM);
85f07f22
FB
2017 goto fail1;
2018}
2019
2020#if 0
2021int file_read(const char *filename)
2022{
2023 URLContext *h;
2024 unsigned char buffer[1024];
2025 int len, i;
2026
2027 if (url_open(&h, filename, O_RDONLY) < 0) {
2028 printf("could not open '%s'\n", filename);
2029 return -1;
2030 }
2031 for(;;) {
2032 len = url_read(h, buffer, sizeof(buffer));
2033 if (len <= 0)
2034 break;
2035 for(i=0;i<len;i++) putchar(buffer[i]);
2036 }
2037 url_close(h);
2038 return 0;
2039}
2040#endif
2041
b29f97d1 2042static void opt_format(const char *arg)
85f07f22 2043{
817b23ff
FB
2044 /* compatibility stuff for pgmyuv */
2045 if (!strcmp(arg, "pgmyuv")) {
5b6d5596 2046 pgmyuv_compatibility_hack=1;
9286699a 2047// opt_image_format(arg);
5b6d5596 2048 arg = "image2";
817b23ff
FB
2049 }
2050
79fdaa4c
FB
2051 file_iformat = av_find_input_format(arg);
2052 file_oformat = guess_format(arg, NULL, NULL);
2053 if (!file_iformat && !file_oformat) {
2054 fprintf(stderr, "Unknown input or output format: %s\n", arg);
85f07f22
FB
2055 exit(1);
2056 }
85f07f22
FB
2057}
2058
b29f97d1 2059static void opt_video_rc_eq(char *arg)
3aa102be
MN
2060{
2061 video_rc_eq = arg;
2062}
2063
b29f97d1 2064static void opt_video_rc_override_string(char *arg)
ac2830ec
MN
2065{
2066 video_rc_override_string = arg;
2067}
2068
f4f3223f
MN
2069static void opt_me_threshold(const char *arg)
2070{
2071 me_threshold = atoi(arg);
2072}
2073
f068206e
BE
2074static void opt_verbose(const char *arg)
2075{
2076 verbose = atoi(arg);
ab1c6dc9 2077 av_log_level = atoi(arg);
f068206e
BE
2078}
2079
b29f97d1 2080static void opt_frame_rate(const char *arg)
85f07f22 2081{
445f1b83
RS
2082 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2083 fprintf(stderr, "Incorrect frame rate\n");
bb270c08 2084 exit(1);
445f1b83 2085 }
85f07f22
FB
2086}
2087
b29f97d1 2088static void opt_frame_crop_top(const char *arg)
ab6d194a 2089{
115329f1 2090 frame_topBand = atoi(arg);
ab6d194a
MN
2091 if (frame_topBand < 0) {
2092 fprintf(stderr, "Incorrect top crop size\n");
2093 exit(1);
2094 }
2095 if ((frame_topBand % 2) != 0) {
2096 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2097 exit(1);
2098 }
2099 if ((frame_topBand) >= frame_height){
bb270c08 2100 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2101 exit(1);
2102 }
2103 frame_height -= frame_topBand;
2104}
2105
b29f97d1 2106static void opt_frame_crop_bottom(const char *arg)
ab6d194a
MN
2107{
2108 frame_bottomBand = atoi(arg);
2109 if (frame_bottomBand < 0) {
2110 fprintf(stderr, "Incorrect bottom crop size\n");
2111 exit(1);
2112 }
2113 if ((frame_bottomBand % 2) != 0) {
2114 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
115329f1 2115 exit(1);
ab6d194a
MN
2116 }
2117 if ((frame_bottomBand) >= frame_height){
bb270c08 2118 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2119 exit(1);
2120 }
2121 frame_height -= frame_bottomBand;
2122}
2123
b29f97d1 2124static void opt_frame_crop_left(const char *arg)
ab6d194a
MN
2125{
2126 frame_leftBand = atoi(arg);
2127 if (frame_leftBand < 0) {
2128 fprintf(stderr, "Incorrect left crop size\n");
2129 exit(1);
2130 }
2131 if ((frame_leftBand % 2) != 0) {
2132 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2133 exit(1);
2134 }
2135 if ((frame_leftBand) >= frame_width){
bb270c08 2136 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2137 exit(1);
2138 }
2139 frame_width -= frame_leftBand;
2140}
2141
b29f97d1 2142static void opt_frame_crop_right(const char *arg)
ab6d194a
MN
2143{
2144 frame_rightBand = atoi(arg);
2145 if (frame_rightBand < 0) {
2146 fprintf(stderr, "Incorrect right crop size\n");
2147 exit(1);
2148 }
2149 if ((frame_rightBand % 2) != 0) {
2150 fprintf(stderr, "Right crop size must be a multiple of 2\n");
115329f1 2151 exit(1);
ab6d194a
MN
2152 }
2153 if ((frame_rightBand) >= frame_width){
bb270c08 2154 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2155 exit(1);
2156 }
2157 frame_width -= frame_rightBand;
2158}
2159
b29f97d1 2160static void opt_frame_size(const char *arg)
85f07f22 2161{
445f1b83 2162 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
85f07f22
FB
2163 fprintf(stderr, "Incorrect frame size\n");
2164 exit(1);
2165 }
2166 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2167 fprintf(stderr, "Frame size must be a multiple of 2\n");
2168 exit(1);
2169 }
2170}
2171
1ff93ffc
TK
2172
2173#define SCALEBITS 10
2174#define ONE_HALF (1 << (SCALEBITS - 1))
bb270c08 2175#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
1ff93ffc
TK
2176
2177#define RGB_TO_Y(r, g, b) \
2178((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2179 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2180
2181#define RGB_TO_U(r1, g1, b1, shift)\
2182(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2183 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2184
2185#define RGB_TO_V(r1, g1, b1, shift)\
2186(((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2187 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2188
2189static void opt_pad_color(const char *arg) {
2190 /* Input is expected to be six hex digits similar to
2191 how colors are expressed in html tags (but without the #) */
2192 int rgb = strtol(arg, NULL, 16);
2193 int r,g,b;
115329f1
DB
2194
2195 r = (rgb >> 16);
1ff93ffc
TK
2196 g = ((rgb >> 8) & 255);
2197 b = (rgb & 255);
2198
2199 padcolor[0] = RGB_TO_Y(r,g,b);
2200 padcolor[1] = RGB_TO_U(r,g,b,0);
2201 padcolor[2] = RGB_TO_V(r,g,b,0);
2202}
2203
2204static void opt_frame_pad_top(const char *arg)
2205{
115329f1 2206 frame_padtop = atoi(arg);
1ff93ffc
TK
2207 if (frame_padtop < 0) {
2208 fprintf(stderr, "Incorrect top pad size\n");
2209 exit(1);
2210 }
2211 if ((frame_padtop % 2) != 0) {
2212 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2213 exit(1);
2214 }
2215}
2216
2217static void opt_frame_pad_bottom(const char *arg)
2218{
115329f1 2219 frame_padbottom = atoi(arg);
1ff93ffc
TK
2220 if (frame_padbottom < 0) {
2221 fprintf(stderr, "Incorrect bottom pad size\n");
2222 exit(1);
2223 }
2224 if ((frame_padbottom % 2) != 0) {
2225 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2226 exit(1);
2227 }
2228}
2229
2230
2231static void opt_frame_pad_left(const char *arg)
2232{
115329f1 2233 frame_padleft = atoi(arg);
1ff93ffc
TK
2234 if (frame_padleft < 0) {
2235 fprintf(stderr, "Incorrect left pad size\n");
2236 exit(1);
2237 }
2238 if ((frame_padleft % 2) != 0) {
2239 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2240 exit(1);
2241 }
2242}
2243
2244
2245static void opt_frame_pad_right(const char *arg)
2246{
115329f1 2247 frame_padright = atoi(arg);
1ff93ffc
TK
2248 if (frame_padright < 0) {
2249 fprintf(stderr, "Incorrect right pad size\n");
2250 exit(1);
2251 }
2252 if ((frame_padright % 2) != 0) {
2253 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2254 exit(1);
2255 }
2256}
2257
2258
63167088
RS
2259static void opt_frame_pix_fmt(const char *arg)
2260{
2261 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2262}
2263
5fe03e38
RS
2264static void opt_frame_aspect_ratio(const char *arg)
2265{
2266 int x = 0, y = 0;
2267 double ar = 0;
2268 const char *p;
115329f1 2269
5fe03e38
RS
2270 p = strchr(arg, ':');
2271 if (p) {
2272 x = strtol(arg, (char **)&arg, 10);
bb270c08
DB
2273 if (arg == p)
2274 y = strtol(arg+1, (char **)&arg, 10);
2275 if (x > 0 && y > 0)
2276 ar = (double)x / (double)y;
5fe03e38
RS
2277 } else
2278 ar = strtod(arg, (char **)&arg);
2279
2280 if (!ar) {
2281 fprintf(stderr, "Incorrect aspect ratio specification.\n");
bb270c08 2282 exit(1);
5fe03e38
RS
2283 }
2284 frame_aspect_ratio = ar;
2285}
2286
b29f97d1 2287static void opt_qscale(const char *arg)
85f07f22 2288{
158c7f05 2289 video_qscale = atof(arg);
4e64bead 2290 if (video_qscale <= 0 ||
158c7f05 2291 video_qscale > 255) {
4e64bead 2292 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
85f07f22
FB
2293 exit(1);
2294 }
2295}
2296
b29f97d1 2297static void opt_qdiff(const char *arg)
9cdd6a24
MN
2298{
2299 video_qdiff = atoi(arg);
2300 if (video_qdiff < 0 ||
2301 video_qdiff > 31) {
2302 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2303 exit(1);
2304 }
2305}
2306
b29f97d1 2307static void opt_strict(const char *arg)
f560dd82
MN
2308{
2309 strict= atoi(arg);
2310}
2311
bb198e19
MN
2312static void opt_top_field_first(const char *arg)
2313{
2314 top_field_first= atoi(arg);
2315}
2316
9c3d33d6
MN
2317static void opt_thread_count(const char *arg)
2318{
2319 thread_count= atoi(arg);
2450cff2 2320#if !defined(HAVE_THREADS)
d8019eb5
AD
2321 if (verbose >= 0)
2322 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
842b556a 2323#endif
9c3d33d6
MN
2324}
2325
b29f97d1 2326static void opt_audio_bitrate(const char *arg)
85f07f22
FB
2327{
2328 audio_bit_rate = atoi(arg) * 1000;
2329}
2330
b29f97d1 2331static void opt_audio_rate(const char *arg)
85f07f22
FB
2332{
2333 audio_sample_rate = atoi(arg);
2334}
2335
b29f97d1 2336static void opt_audio_channels(const char *arg)
85f07f22
FB
2337{
2338 audio_channels = atoi(arg);
2339}
2340
b29f97d1 2341static void opt_video_channel(const char *arg)
a5df11ab
FB
2342{
2343 video_channel = strtol(arg, NULL, 0);
2344}
2345
e3ee3283
AB
2346static void opt_video_standard(const char *arg)
2347{
2348 video_standard = av_strdup(arg);
2349}
2350
cf7fc795
FB
2351static void opt_codec(int *pstream_copy, int *pcodec_id,
2352 int codec_type, const char *arg)
85f07f22
FB
2353{
2354 AVCodec *p;
2355
1629626f 2356 if (!strcmp(arg, "copy")) {
cf7fc795 2357 *pstream_copy = 1;
85f07f22 2358 } else {
1629626f
FB
2359 p = first_avcodec;
2360 while (p) {
cf7fc795 2361 if (!strcmp(p->name, arg) && p->type == codec_type)
1629626f
FB
2362 break;
2363 p = p->next;
2364 }
2365 if (p == NULL) {
cf7fc795 2366 fprintf(stderr, "Unknown codec '%s'\n", arg);
1629626f
FB
2367 exit(1);
2368 } else {
cf7fc795 2369 *pcodec_id = p->id;
1629626f 2370 }
85f07f22
FB
2371 }
2372}
2373
cf7fc795
FB
2374static void opt_audio_codec(const char *arg)
2375{
2376 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2377}
2378
b2a2197e
MN
2379static void opt_audio_tag(const char *arg)
2380{
2381 char *tail;
2382 audio_codec_tag= strtol(arg, &tail, 0);
2383
2384 if(!tail || *tail)
2385 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2386}
2387
2388static void opt_video_tag(const char *arg)
2389{
2390 char *tail;
2391 video_codec_tag= strtol(arg, &tail, 0);
2392
2393 if(!tail || *tail)
2394 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2395}
2396
b29f97d1 2397static void add_frame_hooker(const char *arg)
10d104e4
PG
2398{
2399 int argc = 0;
2400 char *argv[64];
2401 int i;
e9a9e0c2 2402 char *args = av_strdup(arg);
10d104e4 2403
bee0d9e5
CY
2404 using_vhook = 1;
2405
10d104e4
PG
2406 argv[0] = strtok(args, " ");
2407 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2408 }
2409
2410 i = frame_hook_add(argc, argv);
2411
2412 if (i != 0) {
2413 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2414 exit(1);
2415 }
2416}
2417
85f07f22
FB
2418const char *motion_str[] = {
2419 "zero",
2420 "full",
2421 "log",
2422 "phods",
7084c149
MN
2423 "epzs",
2424 "x1",
51d6a3cf
MN
2425 "hex",
2426 "umh",
2427 "iter",
85f07f22
FB
2428 NULL,
2429};
2430
b29f97d1 2431static void opt_motion_estimation(const char *arg)
85f07f22
FB
2432{
2433 const char **p;
2434 p = motion_str;
2435 for(;;) {
2436 if (!*p) {
2437 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2438 exit(1);
2439 }
2440 if (!strcmp(*p, arg))
2441 break;
2442 p++;
2443 }
101bea5f 2444 me_method = (p - motion_str) + 1;
85f07f22
FB
2445}
2446
b29f97d1 2447static void opt_video_codec(const char *arg)
85f07f22 2448{
cf7fc795
FB
2449 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2450}
85f07f22 2451
cf7fc795
FB
2452static void opt_subtitle_codec(const char *arg)
2453{
2454 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
85f07f22
FB
2455}
2456
b29f97d1 2457static void opt_map(const char *arg)
85f07f22
FB
2458{
2459 AVStreamMap *m;
2460 const char *p;
2461
2462 p = arg;
2463 m = &stream_maps[nb_stream_maps++];
2464
2465 m->file_index = strtol(arg, (char **)&p, 0);
2466 if (*p)
2467 p++;
a5dc85ef
J
2468
2469 m->stream_index = strtol(p, (char **)&p, 0);
b4a3389e
WG
2470 if (*p) {
2471 p++;
2472 m->sync_file_index = strtol(p, (char **)&p, 0);
2473 if (*p)
2474 p++;
2475 m->sync_stream_index = strtol(p, (char **)&p, 0);
2476 } else {
2477 m->sync_file_index = m->file_index;
2478 m->sync_stream_index = m->stream_index;
2479 }
85f07f22
FB
2480}
2481
0a38bafd
PB
2482static void opt_map_meta_data(const char *arg)
2483{
2484 AVMetaDataMap *m;
2485 const char *p;
115329f1 2486
0a38bafd
PB
2487 p = arg;
2488 m = &meta_data_maps[nb_meta_data_maps++];
2489
2490 m->out_file = strtol(arg, (char **)&p, 0);
2491 if (*p)
2492 p++;
2493
2494 m->in_file = strtol(p, (char **)&p, 0);
2495}
2496
b29f97d1 2497static void opt_recording_time(const char *arg)
85f07f22
FB
2498{
2499 recording_time = parse_date(arg, 1);
2500}
2501
8831db5c
MN
2502static void opt_start_time(const char *arg)
2503{
2504 start_time = parse_date(arg, 1);
2505}
2506
4568325a
RS
2507static void opt_rec_timestamp(const char *arg)
2508{
2509 rec_timestamp = parse_date(arg, 0) / 1000000;
2510}
2511
a6a92a9a
WG
2512static void opt_input_ts_offset(const char *arg)
2513{
2514 input_ts_offset = parse_date(arg, 1);
2515}
2516
b29f97d1 2517static void opt_input_file(const char *filename)
85f07f22
FB
2518{
2519 AVFormatContext *ic;
2520 AVFormatParameters params, *ap = &params;
14bea432 2521 int err, i, ret, rfps, rfps_base;
bd1b79a1 2522 int64_t timestamp;
85f07f22 2523
b242baa4
FB
2524 if (!strcmp(filename, "-"))
2525 filename = "pipe:";
2526
115329f1 2527 using_stdin |= !strncmp(filename, "pipe:", 5) ||
d9a916e2
CY
2528 !strcmp( filename, "/dev/stdin" );
2529
85f07f22 2530 /* get default parameters from command line */
4eb72c6b
NS
2531 ic = av_alloc_format_context();
2532
79fdaa4c 2533 memset(ap, 0, sizeof(*ap));
4eb72c6b 2534 ap->prealloced_context = 1;
79fdaa4c
FB
2535 ap->sample_rate = audio_sample_rate;
2536 ap->channels = audio_channels;
c0df9d75
MN
2537 ap->time_base.den = frame_rate;
2538 ap->time_base.num = frame_rate_base;
1ff93ffc
TK
2539 ap->width = frame_width + frame_padleft + frame_padright;
2540 ap->height = frame_height + frame_padtop + frame_padbottom;
63167088 2541 ap->pix_fmt = frame_pix_fmt;
2639c651
RS
2542 ap->channel = video_channel;
2543 ap->standard = video_standard;
5b6d5596
MN
2544 ap->video_codec_id = video_codec_id;
2545 ap->audio_codec_id = audio_codec_id;
2546 if(pgmyuv_compatibility_hack)
2547 ap->video_codec_id= CODEC_ID_PGMYUV;
79fdaa4c 2548
4eb72c6b 2549 for(i=0; i<opt_name_count; i++){
bd31a388 2550 const AVOption *opt;
4eb72c6b
NS
2551 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2552 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2553 av_set_double(ic, opt_names[i], d);
2554 }
79fdaa4c
FB
2555 /* open the input file with generic libav function */
2556 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
85f07f22 2557 if (err < 0) {
79fdaa4c 2558 print_error(filename, err);
85f07f22
FB
2559 exit(1);
2560 }
30bc6613 2561
5894e1bb
VP
2562 ic->loop_input = loop_input;
2563
79fdaa4c
FB
2564 /* If not enough info to get the stream parameters, we decode the
2565 first frames to get it. (used in mpeg case for example) */
2566 ret = av_find_stream_info(ic);
d8019eb5 2567 if (ret < 0 && verbose >= 0) {
85f07f22
FB
2568 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2569 exit(1);
2570 }
2571
bd1b79a1
MN
2572 timestamp = start_time;
2573 /* add the stream start time */
2574 if (ic->start_time != AV_NOPTS_VALUE)
2575 timestamp += ic->start_time;
2576
254abc2e
FB
2577 /* if seeking requested, we execute it */
2578 if (start_time != 0) {
3ba1438d 2579 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
254abc2e 2580 if (ret < 0) {
115329f1 2581 fprintf(stderr, "%s: could not seek to position %0.3f\n",
254abc2e
FB
2582 filename, (double)timestamp / AV_TIME_BASE);
2583 }
2584 /* reset seek info */
2585 start_time = 0;
2586 }
2587
85f07f22
FB
2588 /* update the current parameters so that they match the one of the input stream */
2589 for(i=0;i<ic->nb_streams;i++) {
637b5326 2590 int j;
01f4895c 2591 AVCodecContext *enc = ic->streams[i]->codec;
2450cff2 2592#if defined(HAVE_THREADS)
c62c07d3
MN
2593 if(thread_count>1)
2594 avcodec_thread_init(enc, thread_count);
2595#endif
2596 enc->thread_count= thread_count;
85f07f22
FB
2597 switch(enc->codec_type) {
2598 case CODEC_TYPE_AUDIO:
637b5326 2599 for(j=0; j<opt_name_count; j++){
bd31a388 2600 const AVOption *opt;
23b254fb 2601 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
637b5326
MN
2602 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2603 av_set_double(enc, opt_names[j], d);
2604 }
e0d2714a 2605 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
85f07f22
FB
2606 audio_channels = enc->channels;
2607 audio_sample_rate = enc->sample_rate;
b4aea108 2608 if(audio_disable)
f3356e9c 2609 ic->streams[i]->discard= AVDISCARD_ALL;
85f07f22
FB
2610 break;
2611 case CODEC_TYPE_VIDEO:
637b5326 2612 for(j=0; j<opt_name_count; j++){
bd31a388 2613 const AVOption *opt;
23b254fb 2614 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
637b5326
MN
2615 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2616 av_set_double(enc, opt_names[j], d);
2617 }
85f07f22
FB
2618 frame_height = enc->height;
2619 frame_width = enc->width;
bb270c08
DB
2620 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2621 frame_pix_fmt = enc->pix_fmt;
c0df9d75
MN
2622 rfps = ic->streams[i]->r_frame_rate.num;
2623 rfps_base = ic->streams[i]->r_frame_rate.den;
637b5326 2624 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
f4f3223f
MN
2625 if(me_threshold)
2626 enc->debug |= FF_DEBUG_MV;
d7425f59 2627
115329f1 2628 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
d8019eb5
AD
2629
2630 if (verbose >= 0)
386c88de 2631 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
c0df9d75 2632 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
d8019eb5 2633
15bc38e5 2634 (float)rfps / rfps_base, rfps, rfps_base);
79fdaa4c 2635 }
bf5af568 2636 /* update the current frame rate to match the stream frame rate */
14bea432
MN
2637 frame_rate = rfps;
2638 frame_rate_base = rfps_base;
bdfcbbed
MK
2639
2640 enc->rate_emu = rate_emu;
b4aea108 2641 if(video_disable)
f3356e9c
MN
2642 ic->streams[i]->discard= AVDISCARD_ALL;
2643 else if(video_discard)
2644 ic->streams[i]->discard= video_discard;
85f07f22 2645 break;
254abc2e
FB
2646 case CODEC_TYPE_DATA:
2647 break;
cf7fc795
FB
2648 case CODEC_TYPE_SUBTITLE:
2649 break;
ae38261e
MB
2650 case CODEC_TYPE_UNKNOWN:
2651 break;
51bd4565 2652 default:
c04643a2 2653 av_abort();
85f07f22
FB
2654 }
2655 }
115329f1 2656
85f07f22 2657 input_files[nb_input_files] = ic;
bd1b79a1 2658 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
85f07f22 2659 /* dump the file content */
d8019eb5
AD
2660 if (verbose >= 0)
2661 dump_format(ic, nb_input_files, filename, 0);
2662
85f07f22 2663 nb_input_files++;
79fdaa4c
FB
2664 file_iformat = NULL;
2665 file_oformat = NULL;
bdfcbbed 2666
2639c651 2667 video_channel = 0;
115329f1 2668
bdfcbbed 2669 rate_emu = 0;
85f07f22
FB
2670}
2671
b29f97d1 2672static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
919f448d
FB
2673{
2674 int has_video, has_audio, i, j;
2675 AVFormatContext *ic;
2676
2677 has_video = 0;
2678 has_audio = 0;
2679 for(j=0;j<nb_input_files;j++) {
2680 ic = input_files[j];
2681 for(i=0;i<ic->nb_streams;i++) {
01f4895c 2682 AVCodecContext *enc = ic->streams[i]->codec;
919f448d
FB
2683 switch(enc->codec_type) {
2684 case CODEC_TYPE_AUDIO:
2685 has_audio = 1;
2686 break;
2687 case CODEC_TYPE_VIDEO:
2688 has_video = 1;
2689 break;
6fb316d5 2690 case CODEC_TYPE_DATA:
ae38261e 2691 case CODEC_TYPE_UNKNOWN:
cf7fc795 2692 case CODEC_TYPE_SUBTITLE:
6fb316d5 2693 break;
51bd4565 2694 default:
c04643a2 2695 av_abort();
919f448d
FB
2696 }
2697 }
2698 }
2699 *has_video_ptr = has_video;
2700 *has_audio_ptr = has_audio;
2701}
2702
cf7fc795 2703static void new_video_stream(AVFormatContext *oc)
85f07f22
FB
2704{
2705 AVStream *st;
cf7fc795
FB
2706 AVCodecContext *video_enc;
2707 int codec_id;
115329f1 2708
cf7fc795
FB
2709 st = av_new_stream(oc, oc->nb_streams);
2710 if (!st) {
2711 fprintf(stderr, "Could not alloc stream\n");
2712 exit(1);
2713 }
748c2fca
MN
2714 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2715 video_bitstream_filters= NULL;
2716
cf7fc795
FB
2717#if defined(HAVE_THREADS)
2718 if(thread_count>1)
01f4895c 2719 avcodec_thread_init(st->codec, thread_count);
cf7fc795 2720#endif
115329f1 2721
01f4895c 2722 video_enc = st->codec;
115329f1 2723
cf7fc795
FB
2724 if(video_codec_tag)
2725 video_enc->codec_tag= video_codec_tag;
115329f1 2726
90ad92b3 2727 if( (video_global_header&1)
637b5326 2728 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
cf7fc795 2729 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
23b254fb 2730 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
637b5326
MN
2731 }
2732 if(video_global_header&2){
90ad92b3 2733 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
23b254fb 2734 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
637b5326 2735 }
90ad92b3 2736
cf7fc795
FB
2737 if (video_stream_copy) {
2738 st->stream_copy = 1;
2739 video_enc->codec_type = CODEC_TYPE_VIDEO;
2740 } else {
2741 char *p;
2742 int i;
2743 AVCodec *codec;
115329f1 2744
cf7fc795
FB
2745 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2746 if (video_codec_id != CODEC_ID_NONE)
2747 codec_id = video_codec_id;
115329f1 2748
cf7fc795
FB
2749 video_enc->codec_id = codec_id;
2750 codec = avcodec_find_encoder(codec_id);
115329f1 2751
8bbf6db9 2752 for(i=0; i<opt_name_count; i++){
bd31a388 2753 const AVOption *opt;
23b254fb 2754 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
8bbf6db9
MN
2755 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2756 av_set_double(video_enc, opt_names[i], d);
2757 }
115329f1 2758
115329f1
DB
2759 video_enc->time_base.den = frame_rate;
2760 video_enc->time_base.num = frame_rate_base;
cf7fc795
FB
2761 if(codec && codec->supported_framerates){
2762 const AVRational *p= codec->supported_framerates;
2763 AVRational req= (AVRational){frame_rate, frame_rate_base};
2764 const AVRational *best=NULL;
2765 AVRational best_error= (AVRational){INT_MAX, 1};
2766 for(; p->den!=0; p++){
2767 AVRational error= av_sub_q(req, *p);
2768 if(error.num <0) error.num *= -1;
2769 if(av_cmp_q(error, best_error) < 0){
2770 best_error= error;
2771 best= p;
2772 }
2773 }
2774 video_enc->time_base.den= best->num;
2775 video_enc->time_base.num= best->den;
2776 }
115329f1 2777
cf7fc795
FB
2778 video_enc->width = frame_width + frame_padright + frame_padleft;
2779 video_enc->height = frame_height + frame_padtop + frame_padbottom;
e7268d51 2780 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
cf7fc795
FB
2781 video_enc->pix_fmt = frame_pix_fmt;
2782
2783 if(codec && codec->pix_fmts){
2784 const enum PixelFormat *p= codec->pix_fmts;
2785 for(; *p!=-1; p++){
2786 if(*p == video_enc->pix_fmt)
2787 break;
2788 }
2789 if(*p == -1)
2790 video_enc->pix_fmt = codec->pix_fmts[0];
2791 }
2792
babe0e8c 2793 if (intra_only)
cf7fc795
FB
2794 video_enc->gop_size = 0;
2795 if (video_qscale || same_quality) {
2796 video_enc->flags |= CODEC_FLAG_QSCALE;
115329f1 2797 video_enc->global_quality=
cf7fc795
FB
2798 st->quality = FF_QP2LAMBDA * video_qscale;
2799 }
2800
2801 if(intra_matrix)
2802 video_enc->intra_matrix = intra_matrix;
2803 if(inter_matrix)
2804 video_enc->inter_matrix = inter_matrix;
2805
cf7fc795 2806 video_enc->max_qdiff = video_qdiff;
cf7fc795 2807 video_enc->rc_eq = video_rc_eq;
cf7fc795
FB
2808 video_enc->thread_count = thread_count;
2809 p= video_rc_override_string;
2810 for(i=0; p; i++){
2811 int start, end, q;
2812 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2813 if(e!=3){
2814 fprintf(stderr, "error parsing rc_override\n");
2815 exit(1);
2816 }
115329f1
DB
2817 video_enc->rc_override=
2818 av_realloc(video_enc->rc_override,
cf7fc795
FB
2819 sizeof(RcOverride)*(i+1));
2820 video_enc->rc_override[i].start_frame= start;
2821 video_enc->rc_override[i].end_frame = end;
2822 if(q>0){
2823 video_enc->rc_override[i].qscale= q;
2824 video_enc->rc_override[i].quality_factor= 1.0;
2825 }
2826 else{
2827 video_enc->rc_override[i].qscale= 0;
2828 video_enc->rc_override[i].quality_factor= -q/100.0;
2829 }
2830 p= strchr(p, '/');
2831 if(p) p++;
2832 }
2833 video_enc->rc_override_count=i;
079e8cb9
BC
2834 if (!video_enc->rc_initial_buffer_occupancy)
2835 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
cf7fc795 2836 video_enc->me_threshold= me_threshold;
cf7fc795
FB
2837 video_enc->intra_dc_precision= intra_dc_precision - 8;
2838 video_enc->strict_std_compliance = strict;
cf7fc795 2839
cf7fc795
FB
2840 if (do_psnr)
2841 video_enc->flags|= CODEC_FLAG_PSNR;
115329f1 2842
cf7fc795
FB
2843 video_enc->me_method = me_method;
2844
2845 /* two pass mode */
2846 if (do_pass) {
2847 if (do_pass == 1) {
2848 video_enc->flags |= CODEC_FLAG_PASS1;
2849 } else {
2850 video_enc->flags |= CODEC_FLAG_PASS2;
2851 }
2852 }
2853 }
2854
2855 /* reset some key parameters */
2856 video_disable = 0;
2857 video_codec_id = CODEC_ID_NONE;
2858 video_stream_copy = 0;
2859}
2860
2861static void new_audio_stream(AVFormatContext *oc)
2862{
2863 AVStream *st;
2864 AVCodecContext *audio_enc;
8bbf6db9 2865 int codec_id, i;
115329f1 2866
cf7fc795
FB
2867 st = av_new_stream(oc, oc->nb_streams);
2868 if (!st) {
2869 fprintf(stderr, "Could not alloc stream\n");
2870 exit(1);
2871 }
748c2fca
MN
2872
2873 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2874 audio_bitstream_filters= NULL;
2875
cf7fc795
FB
2876#if defined(HAVE_THREADS)
2877 if(thread_count>1)
01f4895c 2878 avcodec_thread_init(st->codec, thread_count);
cf7fc795 2879#endif
115329f1 2880
01f4895c 2881 audio_enc = st->codec;
cf7fc795 2882 audio_enc->codec_type = CODEC_TYPE_AUDIO;
f889d3f9 2883 audio_enc->strict_std_compliance = strict;
115329f1 2884
cf7fc795
FB
2885 if(audio_codec_tag)
2886 audio_enc->codec_tag= audio_codec_tag;
115329f1 2887
637b5326 2888 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
cf7fc795 2889 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
23b254fb 2890 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
637b5326 2891 }
cf7fc795
FB
2892 if (audio_stream_copy) {
2893 st->stream_copy = 1;
2894 audio_enc->channels = audio_channels;
2895 } else {
2896 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
115329f1 2897
8bbf6db9 2898 for(i=0; i<opt_name_count; i++){
bd31a388 2899 const AVOption *opt;
23b254fb 2900 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
8bbf6db9
MN
2901 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2902 av_set_double(audio_enc, opt_names[i], d);
2903 }
115329f1 2904
cf7fc795
FB
2905 if (audio_codec_id != CODEC_ID_NONE)
2906 codec_id = audio_codec_id;
2907 audio_enc->codec_id = codec_id;
115329f1 2908
cf7fc795 2909 audio_enc->bit_rate = audio_bit_rate;
c57c770d
JR
2910 if (audio_qscale > QSCALE_NONE) {
2911 audio_enc->flags |= CODEC_FLAG_QSCALE;
2912 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2913 }
cf7fc795 2914 audio_enc->thread_count = thread_count;
e3e3be53 2915 audio_enc->channels = audio_channels;
cf7fc795
FB
2916 }
2917 audio_enc->sample_rate = audio_sample_rate;
78e03516 2918 audio_enc->time_base= (AVRational){1, audio_sample_rate};
cf7fc795
FB
2919 if (audio_language) {
2920 pstrcpy(st->language, sizeof(st->language), audio_language);
2921 av_free(audio_language);
2922 audio_language = NULL;
2923 }
2924
2925 /* reset some key parameters */
2926 audio_disable = 0;
2927 audio_codec_id = CODEC_ID_NONE;
2928 audio_stream_copy = 0;
2929}
2930
2931static void opt_new_subtitle_stream(void)
2932{
2933 AVFormatContext *oc;
2934 AVStream *st;
2935 AVCodecContext *subtitle_enc;
8bbf6db9 2936 int i;
115329f1 2937
cf7fc795
FB
2938 if (nb_output_files <= 0) {
2939 fprintf(stderr, "At least one output file must be specified\n");
2940 exit(1);
2941 }
2942 oc = output_files[nb_output_files - 1];
2943
2944 st = av_new_stream(oc, oc->nb_streams);
2945 if (!st) {
2946 fprintf(stderr, "Could not alloc stream\n");
2947 exit(1);
2948 }
2949
01f4895c 2950 subtitle_enc = st->codec;
cf7fc795
FB
2951 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2952 if (subtitle_stream_copy) {
2953 st->stream_copy = 1;
2954 } else {
8bbf6db9 2955 for(i=0; i<opt_name_count; i++){
bd31a388 2956 const AVOption *opt;
23b254fb 2957 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
8bbf6db9
MN
2958 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2959 av_set_double(subtitle_enc, opt_names[i], d);
2960 }
cf7fc795
FB
2961 subtitle_enc->codec_id = subtitle_codec_id;
2962 }
2963
2964 if (subtitle_language) {
2965 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2966 av_free(subtitle_language);
2967 subtitle_language = NULL;
2968 }
2969
2970 subtitle_codec_id = CODEC_ID_NONE;
2971 subtitle_stream_copy = 0;
2972}
2973
2974static void opt_new_audio_stream(void)
2975{
2976 AVFormatContext *oc;
2977 if (nb_output_files <= 0) {
2978 fprintf(stderr, "At least one output file must be specified\n");
2979 exit(1);
2980 }
2981 oc = output_files[nb_output_files - 1];
2982 new_audio_stream(oc);
2983}
2984
2985static void opt_new_video_stream(void)
2986{
2987 AVFormatContext *oc;
2988 if (nb_output_files <= 0) {
2989 fprintf(stderr, "At least one output file must be specified\n");
2990 exit(1);
2991 }
2992 oc = output_files[nb_output_files - 1];
2993 new_video_stream(oc);
2994}
2995
2996static void opt_output_file(const char *filename)
2997{
2998 AVFormatContext *oc;
8e16b25c 2999 int use_video, use_audio, input_has_video, input_has_audio, i;
817b23ff 3000 AVFormatParameters params, *ap = &params;
85f07f22
FB
3001
3002 if (!strcmp(filename, "-"))
3003 filename = "pipe:";
3004
bc874dae 3005 oc = av_alloc_format_context();
85f07f22 3006
79fdaa4c
FB
3007 if (!file_oformat) {
3008 file_oformat = guess_format(NULL, filename, NULL);
3009 if (!file_oformat) {
3010 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3011 filename);
3012 exit(1);
3013 }
85f07f22 3014 }
115329f1 3015
79fdaa4c 3016 oc->oformat = file_oformat;
cf7fc795 3017 pstrcpy(oc->filename, sizeof(oc->filename), filename);
85f07f22 3018
115329f1 3019 if (!strcmp(file_oformat->name, "ffm") &&
85f07f22
FB
3020 strstart(filename, "http:", NULL)) {
3021 /* special case for files sent to ffserver: we get the stream
3022 parameters from ffserver */
3023 if (read_ffserver_streams(oc, filename) < 0) {
3024 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3025 exit(1);
3026 }
3027 } else {
f2d9a9f5
LA
3028 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3029 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
919f448d 3030
e30a2846
FB
3031 /* disable if no corresponding type found and at least one
3032 input file */
3033 if (nb_input_files > 0) {
3034 check_audio_video_inputs(&input_has_video, &input_has_audio);
3035 if (!input_has_video)
3036 use_video = 0;
3037 if (!input_has_audio)
3038 use_audio = 0;
3039 }
919f448d
FB
3040
3041 /* manual disable */
85f07f22
FB
3042 if (audio_disable) {
3043 use_audio = 0;
3044 }
3045 if (video_disable) {
3046 use_video = 0;
3047 }
115329f1 3048
85f07f22 3049 if (use_video) {
cf7fc795 3050 new_video_stream(oc);
85f07f22 3051 }
115329f1 3052
85f07f22 3053 if (use_audio) {
cf7fc795 3054 new_audio_stream(oc);
85f07f22
FB
3055 }
3056
4568325a 3057 oc->timestamp = rec_timestamp;
115329f1 3058
bb270c08 3059 if (str_title)
79fdaa4c 3060 pstrcpy(oc->title, sizeof(oc->title), str_title);
85f07f22 3061 if (str_author)
79fdaa4c 3062 pstrcpy(oc->author, sizeof(oc->author), str_author);
85f07f22 3063 if (str_copyright)
79fdaa4c 3064 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
85f07f22 3065 if (str_comment)
79fdaa4c 3066 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
63d5075c
PI
3067 if (str_album)
3068 pstrcpy(oc->album, sizeof(oc->album), str_album);
85f07f22
FB
3069 }
3070
1629626f 3071 output_files[nb_output_files++] = oc;
85f07f22 3072
919f448d 3073 /* check filename in case of an image number is expected */
79fdaa4c 3074 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5c07cf53 3075 if (!av_filename_number_test(oc->filename)) {
79fdaa4c 3076 print_error(oc->filename, AVERROR_NUMEXPECTED);
919f448d 3077 exit(1);
79fdaa4c 3078 }
919f448d
FB
3079 }
3080
79fdaa4c 3081 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
85f07f22 3082 /* test if it already exists to avoid loosing precious files */
115329f1 3083 if (!file_overwrite &&
85f07f22
FB
3084 (strchr(filename, ':') == NULL ||
3085 strstart(filename, "file:", NULL))) {
3086 if (url_exist(filename)) {
3087 int c;
115329f1 3088
d9a916e2
CY
3089 if ( !using_stdin ) {
3090 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3091 fflush(stderr);
3092 c = getchar();
3093 if (toupper(c) != 'Y') {
3094 fprintf(stderr, "Not overwriting - exiting\n");
3095 exit(1);
3096 }
bb270c08
DB
3097 }
3098 else {
d9a916e2 3099 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
85f07f22 3100 exit(1);
bb270c08 3101 }
85f07f22
FB
3102 }
3103 }
115329f1 3104
85f07f22
FB
3105 /* open the file */
3106 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3107 fprintf(stderr, "Could not open '%s'\n", filename);
3108 exit(1);
3109 }
3110 }
3111
817b23ff 3112 memset(ap, 0, sizeof(*ap));
817b23ff
FB
3113 if (av_set_parameters(oc, ap) < 0) {
3114 fprintf(stderr, "%s: Invalid encoding parameters\n",
3115 oc->filename);
3116 exit(1);
3117 }
3118
17c88cb0
MN
3119 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3120 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
8108551a 3121 oc->loop_output = loop_output;
2db3c638 3122
8e16b25c 3123 for(i=0; i<opt_name_count; i++){
bd31a388 3124 const AVOption *opt;
8e16b25c
PI
3125 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3126 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3127 av_set_double(oc, opt_names[i], d);
3128 }
3129
85f07f22 3130 /* reset some options */
79fdaa4c
FB
3131 file_oformat = NULL;
3132 file_iformat = NULL;
85f07f22
FB
3133}
3134
5abdb4b1 3135/* same option as mencoder */
b29f97d1 3136static void opt_pass(const char *pass_str)
5abdb4b1
FB
3137{
3138 int pass;
3139 pass = atoi(pass_str);
3140 if (pass != 1 && pass != 2) {
3141 fprintf(stderr, "pass number can be only 1 or 2\n");
3142 exit(1);
3143 }
3144 do_pass = pass;
3145}
a38469e1 3146
2f30a81d 3147#if defined(__MINGW32__) || defined(CONFIG_OS2)
0c1a9eda 3148static int64_t getutime(void)
5727b222 3149{
f3ec2d46 3150 return av_gettime();
5727b222 3151}
bdc4796f 3152#else
0c1a9eda 3153static int64_t getutime(void)
bdc4796f 3154{
f3ec2d46
SG
3155 struct rusage rusage;
3156
3157 getrusage(RUSAGE_SELF, &rusage);
3158 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
bdc4796f
FB
3159}
3160#endif
5727b222 3161
e8a42081 3162#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
79fdaa4c 3163extern int ffm_nopts;
e8a42081 3164#endif
79fdaa4c 3165
b29f97d1 3166static void show_formats(void)
85f07f22 3167{
79fdaa4c
FB
3168 AVInputFormat *ifmt;
3169 AVOutputFormat *ofmt;
85f07f22 3170 URLProtocol *up;
3738fe1a
MN
3171 AVCodec *p, *p2;
3172 const char **pp, *last_name;
3173
3174 printf("File formats:\n");
3175 last_name= "000";
3176 for(;;){
3177 int decode=0;
3178 int encode=0;
3179 const char *name=NULL;
92a80570 3180 const char *long_name=NULL;
3738fe1a
MN
3181
3182 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3183 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3184 strcmp(ofmt->name, last_name)>0){
3185 name= ofmt->name;
92a80570 3186 long_name= ofmt->long_name;
3738fe1a
MN
3187 encode=1;
3188 }
3189 }
3190 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3191 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3192 strcmp(ifmt->name, last_name)>0){
3193 name= ifmt->name;
92a80570 3194 long_name= ifmt->long_name;
3738fe1a
MN
3195 encode=0;
3196 }
3197 if(name && strcmp(ifmt->name, name)==0)
3198 decode=1;
3199 }
3200 if(name==NULL)
3201 break;
3202 last_name= name;
115329f1 3203
3738fe1a 3204 printf(
115329f1
DB
3205 " %s%s %-15s %s\n",
3206 decode ? "D":" ",
3207 encode ? "E":" ",
92a80570
MN
3208 name,
3209 long_name ? long_name:" ");
817b23ff
FB
3210 }
3211 printf("\n");
3212
85f07f22 3213 printf("Codecs:\n");
3738fe1a
MN
3214 last_name= "000";
3215 for(;;){
3216 int decode=0;
3217 int encode=0;
3218 int cap=0;
cf7fc795 3219 const char *type_str;
3738fe1a
MN
3220
3221 p2=NULL;
3222 for(p = first_avcodec; p != NULL; p = p->next) {
3223 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3224 strcmp(p->name, last_name)>0){
3225 p2= p;
3226 decode= encode= cap=0;
3227 }
3228 if(p2 && strcmp(p->name, p2->name)==0){
3229 if(p->decode) decode=1;
3230 if(p->encode) encode=1;
3231 cap |= p->capabilities;
3232 }
3233 }
3234 if(p2==NULL)
3235 break;
3236 last_name= p2->name;
115329f1 3237
cf7fc795
FB
3238 switch(p2->type) {
3239 case CODEC_TYPE_VIDEO:
3240 type_str = "V";
3241 break;
3242 case CODEC_TYPE_AUDIO:
3243 type_str = "A";
3244 break;
3245 case CODEC_TYPE_SUBTITLE:
3246 type_str = "S";
3247 break;
3248 default:
3249 type_str = "?";
3250 break;
3251 }
3738fe1a 3252 printf(
115329f1
DB
3253 " %s%s%s%s%s%s %s",
3254 decode ? "D": (/*p2->decoder ? "d":*/" "),
3255 encode ? "E":" ",
cf7fc795 3256 type_str,
3738fe1a
MN
3257 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3258 cap & CODEC_CAP_DR1 ? "D":" ",
3259 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3260 p2->name);
3261 /* if(p2->decoder && decode==0)
3262 printf(" use %s for decoding", p2->decoder->name);*/
3263 printf("\n");
85f07f22
FB
3264 }
3265 printf("\n");
3266
3738fe1a 3267 printf("Supported file protocols:\n");
85f07f22
FB
3268 for(up = first_protocol; up != NULL; up = up->next)
3269 printf(" %s:", up->name);
3270 printf("\n");
115329f1 3271
3738fe1a
MN
3272 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3273 printf("Motion estimation methods:\n");
85f07f22
FB
3274 pp = motion_str;
3275 while (*pp) {
3276 printf(" %s", *pp);
115329f1 3277 if ((pp - motion_str + 1) == ME_ZERO)
85f07f22 3278 printf("(fastest)");
115329f1 3279 else if ((pp - motion_str + 1) == ME_FULL)
85f07f22 3280 printf("(slowest)");
115329f1 3281 else if ((pp - motion_str + 1) == ME_EPZS)
85f07f22
FB
3282 printf("(default)");
3283 pp++;
3284 }
3738fe1a
MN
3285 printf("\n\n");
3286 printf(
3287"Note, the names of encoders and decoders dont always match, so there are\n"
3288"several cases where the above table shows encoder only or decoder only entries\n"
3289"even though both encoding and decoding are supported for example, the h263\n"
3290"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3291"worse\n");
85f07f22
FB
3292 exit(1);
3293}
3294
ceaf1909 3295static void parse_matrix_coeffs(uint16_t *dest, const char *str)
84f608f4
VM
3296{
3297 int i;
3298 const char *p = str;
3299 for(i = 0;; i++) {
3300 dest[i] = atoi(p);
3301 if(i == 63)
3302 break;
3303 p = strchr(p, ',');
3304 if(!p) {
3305 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3306 exit(1);
3307 }
3308 p++;
3309 }
3310}
3311
ceaf1909 3312static void opt_inter_matrix(const char *arg)
84f608f4
VM
3313{
3314 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3315 parse_matrix_coeffs(inter_matrix, arg);
3316}
3317
ceaf1909 3318static void opt_intra_matrix(const char *arg)
84f608f4
VM
3319{
3320 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3321 parse_matrix_coeffs(intra_matrix, arg);
3322}
3323
e0595741
VM
3324static void opt_target(const char *arg)
3325{
3326 int norm = -1;
88730be6 3327 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
e0595741
VM
3328
3329 if(!strncmp(arg, "pal-", 4)) {
3330 norm = 0;
3331 arg += 4;
3332 } else if(!strncmp(arg, "ntsc-", 5)) {
3333 norm = 1;
3334 arg += 5;
ed2d7a34
PI
3335 } else if(!strncmp(arg, "film-", 5)) {
3336 norm = 2;
3337 arg += 5;
e0595741
VM
3338 } else {
3339 int fr;
3340 /* Calculate FR via float to avoid int overflow */
3341 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3342 if(fr == 25000) {
3343 norm = 0;
3344 } else if((fr == 29970) || (fr == 23976)) {
3345 norm = 1;
3346 } else {
3347 /* Try to determine PAL/NTSC by peeking in the input files */
3348 if(nb_input_files) {
3349 int i, j;
3350 for(j = 0; j < nb_input_files; j++) {
3351 for(i = 0; i < input_files[j]->nb_streams; i++) {
01f4895c 3352 AVCodecContext *c = input_files[j]->streams[i]->codec;
e0595741
VM
3353 if(c->codec_type != CODEC_TYPE_VIDEO)
3354 continue;
c0df9d75 3355 fr = c->time_base.den * 1000 / c->time_base.num;
e0595741
VM
3356 if(fr == 25000) {
3357 norm = 0;
3358 break;
3359 } else if((fr == 29970) || (fr == 23976))