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