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