change management of "ab" option in ffmpeg.c, so that it works as "b" option.
[libav.git] / ffmpeg.c
CommitLineData
85f07f22 1/*
115329f1 2 * FFmpeg main
01310af2 3 * Copyright (c) 2000-2003 Fabrice Bellard
85f07f22 4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
bf5af568
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
85f07f22 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
85f07f22 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
bf5af568
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
85f07f22 16 *
bf5af568 17 * You should have received a copy of the GNU Lesser General Public
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
85f07f22 20 */
daf8e955 21#define HAVE_AV_CONFIG_H
d86b83f8 22#include <signal.h>
22f7a060 23#include <limits.h>
daf8e955 24#include "avformat.h"
18a54b04 25#include "swscale.h"
10d104e4 26#include "framehook.h"
1ac31760 27#include "dsputil.h"
6fd46414 28#include "opt.h"
f5a478f6 29#include "fifo.h"
daf8e955 30
d86b83f8
RP
31#ifdef __MINGW32__
32#include <conio.h>
33#else
85f07f22
FB
34#include <unistd.h>
35#include <fcntl.h>
36#include <sys/ioctl.h>
85f07f22 37#include <sys/time.h>
85f07f22 38#include <termios.h>
5727b222 39#include <sys/resource.h>
bdc4796f 40#endif
f3ec2d46
SG
41#ifdef CONFIG_OS2
42#include <sys/types.h>
43#include <sys/select.h>
44#include <stdlib.h>
45#endif
64c020a8 46#undef time //needed because HAVE_AV_CONFIG_H is defined on top
bf5af568 47#include <time.h>
85f07f22 48
f1cc88a5 49#include "version.h"
01310af2
FB
50#include "cmdutils.h"
51
2b18dcd0
MN
52#undef NDEBUG
53#include <assert.h>
54
8aa1e3da
MN
55#if !defined(INFINITY) && defined(HUGE_VAL)
56#define INFINITY HUGE_VAL
57#endif
85f07f22 58
85f07f22
FB
59/* select an input stream for an output stream */
60typedef struct AVStreamMap {
61 int file_index;
62 int stream_index;
b4a3389e
WG
63 int sync_file_index;
64 int sync_stream_index;
85f07f22
FB
65} AVStreamMap;
66
0a38bafd
PB
67/** select an input file for an output file */
68typedef struct AVMetaDataMap {
69 int out_file;
70 int in_file;
71} AVMetaDataMap;
72
85f07f22
FB
73extern const OptionDef options[];
74
02d504a7
FB
75static void show_help(void);
76static void show_license(void);
637b5326 77static int opt_default(const char *opt, const char *arg);
85f07f22
FB
78
79#define MAX_FILES 20
80
81static AVFormatContext *input_files[MAX_FILES];
a6a92a9a 82static int64_t input_files_ts_offset[MAX_FILES];
85f07f22
FB
83static int nb_input_files = 0;
84
85static AVFormatContext *output_files[MAX_FILES];
86static int nb_output_files = 0;
87
88static AVStreamMap stream_maps[MAX_FILES];
89static int nb_stream_maps;
90
0a38bafd
PB
91static AVMetaDataMap meta_data_maps[MAX_FILES];
92static int nb_meta_data_maps;
93
79fdaa4c
FB
94static AVInputFormat *file_iformat;
95static AVOutputFormat *file_oformat;
55cf1959
MN
96static int frame_width = 0;
97static int frame_height = 0;
880e8ba7 98static float frame_aspect_ratio = 0;
644a9262 99static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
1ff93ffc
TK
100static int frame_padtop = 0;
101static int frame_padbottom = 0;
102static int frame_padleft = 0;
103static int frame_padright = 0;
104static int padcolor[3] = {16,128,128}; /* default to black */
ab6d194a
MN
105static int frame_topBand = 0;
106static int frame_bottomBand = 0;
107static int frame_leftBand = 0;
108static int frame_rightBand = 0;
cf7fc795 109static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
14bea432
MN
110static int frame_rate = 25;
111static int frame_rate_base = 1;
158c7f05 112static float video_qscale = 0;
9cdd6a24 113static int video_qdiff = 3;
84f608f4
VM
114static uint16_t *intra_matrix = NULL;
115static uint16_t *inter_matrix = NULL;
ac2830ec 116#if 0 //experimental, (can be removed)
3aa102be
MN
117static float video_rc_qsquish=1.0;
118static float video_rc_qmod_amp=0;
119static int video_rc_qmod_freq=0;
ac2830ec 120#endif
3aa102be
MN
121static char *video_rc_override_string=NULL;
122static char *video_rc_eq="tex^qComp";
3bea5386 123static int me_method = ME_EPZS;
85f07f22 124static int video_disable = 0;
f3356e9c 125static int video_discard = 0;
85f07f22 126static int video_codec_id = CODEC_ID_NONE;
b2a2197e 127static int video_codec_tag = 0;
85f07f22 128static int same_quality = 0;
cfcf0ffd 129static int do_deinterlace = 0;
f560dd82 130static int strict = 0;
bb198e19 131static int top_field_first = -1;
f4f3223f 132static int me_threshold = 0;
1a11cbcc 133static int intra_dc_precision = 8;
5894e1bb 134static int loop_input = 0;
8108551a 135static int loop_output = AVFMT_NOOUTPUTLOOP;
0888fd22 136static int qp_hist = 0;
85f07f22 137
85f07f22
FB
138static int intra_only = 0;
139static int audio_sample_rate = 44100;
c57c770d
JR
140#define QSCALE_NONE -99999
141static float audio_qscale = QSCALE_NONE;
85f07f22
FB
142static int audio_disable = 0;
143static int audio_channels = 1;
144static int audio_codec_id = CODEC_ID_NONE;
b2a2197e 145static int audio_codec_tag = 0;
cf7fc795
FB
146static char *audio_language = NULL;
147
148static int subtitle_codec_id = CODEC_ID_NONE;
149static char *subtitle_language = NULL;
85f07f22 150
17c88cb0
MN
151static float mux_preload= 0.5;
152static float mux_max_delay= 0.7;
2db3c638 153
0c1a9eda 154static int64_t recording_time = 0;
8831db5c 155static int64_t start_time = 0;
4568325a 156static int64_t rec_timestamp = 0;
a6a92a9a 157static int64_t input_ts_offset = 0;
85f07f22
FB
158static int file_overwrite = 0;
159static char *str_title = NULL;
160static char *str_author = NULL;
161static char *str_copyright = NULL;
162static char *str_comment = NULL;
63d5075c 163static char *str_album = NULL;
5727b222 164static int do_benchmark = 0;
a0663ba4 165static int do_hex_dump = 0;
254abc2e 166static int do_pkt_dump = 0;
43f1708f 167static int do_psnr = 0;
ce7c56c2 168static int do_vstats = 0;
5abdb4b1
FB
169static int do_pass = 0;
170static char *pass_logfilename = NULL;
1629626f
FB
171static int audio_stream_copy = 0;
172static int video_stream_copy = 0;
cf7fc795 173static int subtitle_stream_copy = 0;
986ebcdb
MN
174static int video_sync_method= 1;
175static int audio_sync_method= 0;
72bd8100 176static int copy_ts= 0;
ca80810b 177static int opt_shortest = 0; //
90ad92b3 178static int video_global_header = 0;
5abdb4b1 179
bdfcbbed
MK
180static int rate_emu = 0;
181
a5df11ab 182static int video_channel = 0;
e3ee3283 183static char *video_standard = "ntsc";
79a7c268 184
a9aa3467 185static int audio_volume = 256;
8aa3ee32 186
d9a916e2 187static int using_stdin = 0;
bee0d9e5 188static int using_vhook = 0;
f068206e 189static int verbose = 1;
9c3d33d6 190static int thread_count= 1;
b51469a0 191static int q_pressed = 0;
1008ceb3
MN
192static int64_t video_size = 0;
193static int64_t audio_size = 0;
194static int64_t extra_size = 0;
a6a92a9a
WG
195static int nb_frames_dup = 0;
196static int nb_frames_drop = 0;
6e454c38 197static int input_sync;
b6e16b86 198static int limit_filesize = 0; //
d9a916e2 199
5b6d5596 200static int pgmyuv_compatibility_hack=0;
023857be 201static int dts_delta_threshold = 10;
5b6d5596 202
18a54b04
LA
203static int sws_flags = SWS_BICUBIC;
204
8bbf6db9
MN
205const char **opt_names=NULL;
206int opt_name_count=0;
23b254fb 207AVCodecContext *avctx_opts[CODEC_TYPE_NB];
4eb72c6b 208AVFormatContext *avformat_opts;
8bbf6db9 209
748c2fca
MN
210static AVBitStreamFilterContext *video_bitstream_filters=NULL;
211static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
212static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
5b6d5596 213
5abdb4b1 214#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
85f07f22 215
b4a3389e
WG
216struct AVInputStream;
217
85f07f22
FB
218typedef struct AVOutputStream {
219 int file_index; /* file index */
220 int index; /* stream index in the output file */
221 int source_index; /* AVInputStream index */
222 AVStream *st; /* stream in the output file */
ec5517d5
FB
223 int encoding_needed; /* true if encoding needed for this stream */
224 int frame_number;
225 /* input pts and corresponding output pts
226 for A/V sync */
b4a3389e
WG
227 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
228 struct AVInputStream *sync_ist; /* input stream to sync against */
e928649b 229 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
85f07f22 230 /* video only */
07d0cdfc 231 int video_resample;
a4d36c11 232 AVFrame pict_tmp; /* temporary image for resampling */
18a54b04
LA
233 struct SwsContext *img_resample_ctx; /* for image resampling */
234 int resample_height;
34b10a57 235
07d0cdfc 236 int video_crop;
34b10a57
D
237 int topBand; /* cropping area sizes */
238 int leftBand;
115329f1 239
07d0cdfc 240 int video_pad;
1ff93ffc
TK
241 int padtop; /* padding area sizes */
242 int padbottom;
243 int padleft;
244 int padright;
115329f1 245
85f07f22
FB
246 /* audio only */
247 int audio_resample;
248 ReSampleContext *resample; /* for audio resampling */
f5a478f6 249 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
5abdb4b1 250 FILE *logfile;
85f07f22
FB
251} AVOutputStream;
252
253typedef struct AVInputStream {
254 int file_index;
255 int index;
256 AVStream *st;
257 int discard; /* true if stream data should be discarded */
258 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
0c1a9eda 259 int64_t sample_index; /* current sample */
bdfcbbed
MK
260
261 int64_t start; /* time when read started */
262 unsigned long frame; /* current frame */
254abc2e
FB
263 int64_t next_pts; /* synthetic pts for cases where pkt.pts
264 is not defined */
e7d0374f 265 int64_t pts; /* current pts */
ff4905a5 266 int is_start; /* is 1 at the start and after a discontinuity */
85f07f22
FB
267} AVInputStream;
268
269typedef struct AVInputFile {
270 int eof_reached; /* true if eof reached */
271 int ist_index; /* index of first stream in ist_table */
272 int buffer_size; /* current total buffer size */
273 int buffer_size_max; /* buffer size at which we consider we can stop
274 buffering */
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
604 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
605
606 if (picture != picture2)
607 *picture = *picture2;
608 *bufp = buf;
609}
610
ec5517d5
FB
611/* we begin to correct av delay at this threshold */
612#define AV_DELAY_MAX 0.100
85f07f22 613
115329f1
DB
614static void do_subtitle_out(AVFormatContext *s,
615 AVOutputStream *ost,
cf7fc795
FB
616 AVInputStream *ist,
617 AVSubtitle *sub,
618 int64_t pts)
619{
620 static uint8_t *subtitle_out = NULL;
621 int subtitle_out_max_size = 65536;
622 int subtitle_out_size, nb, i;
623 AVCodecContext *enc;
624 AVPacket pkt;
625
626 if (pts == AV_NOPTS_VALUE) {
627 fprintf(stderr, "Subtitle packets must have a pts\n");
628 return;
629 }
630
01f4895c 631 enc = ost->st->codec;
cf7fc795
FB
632
633 if (!subtitle_out) {
634 subtitle_out = av_malloc(subtitle_out_max_size);
635 }
636
637 /* Note: DVB subtitle need one packet to draw them and one other
638 packet to clear them */
639 /* XXX: signal it in the codec context ? */
640 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
641 nb = 2;
642 else
643 nb = 1;
644
645 for(i = 0; i < nb; i++) {
115329f1 646 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
cf7fc795 647 subtitle_out_max_size, sub);
115329f1 648
cf7fc795
FB
649 av_init_packet(&pkt);
650 pkt.stream_index = ost->index;
651 pkt.data = subtitle_out;
652 pkt.size = subtitle_out_size;
653 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);
654 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
655 /* XXX: the pts correction is handled here. Maybe handling
656 it in the codec would be better */
657 if (i == 0)
658 pkt.pts += 90 * sub->start_display_time;
659 else
660 pkt.pts += 90 * sub->end_display_time;
661 }
748c2fca 662 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
cf7fc795
FB
663 }
664}
665
8a6cb114 666static int bit_buffer_size= 1024*256;
27537106 667static uint8_t *bit_buffer= NULL;
1ff93ffc 668
115329f1
DB
669static void do_video_out(AVFormatContext *s,
670 AVOutputStream *ost,
85f07f22 671 AVInputStream *ist,
7a0f9d7e 672 AVFrame *in_picture,
986ebcdb 673 int *frame_size)
85f07f22 674{
ec5517d5 675 int nb_frames, i, ret;
07d0cdfc 676 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
18a54b04 677 AVFrame picture_crop_temp, picture_pad_temp;
0c1a9eda 678 uint8_t *buf = NULL, *buf1 = NULL;
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
LA
719 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
720 goto the_end;
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
LA
734 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
735 goto the_end;
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 833 }
ec5517d5 834 the_end:
0f1578af
FB
835 av_free(buf);
836 av_free(buf1);
85f07f22
FB
837}
838
140cb663
MN
839static double psnr(double d){
840 if(d==0) return INFINITY;
b29f97d1 841 return -10.0*log(d)/log(10.0);
140cb663
MN
842}
843
115329f1 844static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
ec5517d5 845 int frame_size)
ce7c56c2
J
846{
847 static FILE *fvstats=NULL;
ce7c56c2 848 char filename[40];
bf5af568
FB
849 time_t today2;
850 struct tm *today;
ce7c56c2
J
851 AVCodecContext *enc;
852 int frame_number;
0c1a9eda 853 int64_t ti;
ce7c56c2 854 double ti1, bitrate, avg_bitrate;
115329f1 855
ce7c56c2
J
856 if (!fvstats) {
857 today2 = time(NULL);
858 today = localtime(&today2);
2fc8ea24 859 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
ce7c56c2
J
860 today->tm_min,
861 today->tm_sec);
862 fvstats = fopen(filename,"w");
863 if (!fvstats) {
864 perror("fopen");
865 exit(1);
866 }
867 }
115329f1 868
f27a7268 869 ti = INT64_MAX;
01f4895c 870 enc = ost->st->codec;
ce7c56c2 871 if (enc->codec_type == CODEC_TYPE_VIDEO) {
ec5517d5 872 frame_number = ost->frame_number;
158c7f05 873 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
140cb663 874 if (enc->flags&CODEC_FLAG_PSNR)
492cd3a9 875 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
115329f1 876
ce7c56c2 877 fprintf(fvstats,"f_size= %6d ", frame_size);
ec5517d5 878 /* compute pts value */
c0df9d75 879 ti1 = ost->sync_opts * av_q2d(enc->time_base);
ce7c56c2
J
880 if (ti1 < 0.01)
881 ti1 = 0.01;
115329f1 882
c0df9d75 883 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1008ceb3 884 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
ce7c56c2 885 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1008ceb3 886 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
115329f1 887 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
ce7c56c2 888 }
ec5517d5
FB
889}
890
b29f97d1 891static void print_report(AVFormatContext **output_files,
bb270c08
DB
892 AVOutputStream **ost_table, int nb_ostreams,
893 int is_last_report)
ec5517d5
FB
894{
895 char buf[1024];
896 AVOutputStream *ost;
897 AVFormatContext *oc, *os;
0c1a9eda 898 int64_t total_size;
ec5517d5
FB
899 AVCodecContext *enc;
900 int frame_number, vid, i;
901 double bitrate, ti1, pts;
0c1a9eda 902 static int64_t last_time = -1;
0888fd22 903 static int qp_histogram[52];
115329f1 904
ec5517d5 905 if (!is_last_report) {
0c1a9eda 906 int64_t cur_time;
ec5517d5
FB
907 /* display the report every 0.5 seconds */
908 cur_time = av_gettime();
909 if (last_time == -1) {
910 last_time = cur_time;
911 return;
115329f1 912 }
ec5517d5
FB
913 if ((cur_time - last_time) < 500000)
914 return;
915 last_time = cur_time;
916 }
917
ce7c56c2 918
ec5517d5
FB
919 oc = output_files[0];
920
921 total_size = url_ftell(&oc->pb);
115329f1 922
ec5517d5
FB
923 buf[0] = '\0';
924 ti1 = 1e10;
925 vid = 0;
926 for(i=0;i<nb_ostreams;i++) {
927 ost = ost_table[i];
928 os = output_files[ost->file_index];
01f4895c 929 enc = ost->st->codec;
10d104e4 930 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
0ecca7a4 931 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
158c7f05 932 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
10d104e4 933 }
ec5517d5
FB
934 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
935 frame_number = ost->frame_number;
0888fd22
MN
936 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
937 frame_number, 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)
78953e62 1053 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, 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 {
01f4895c 1109 switch(ist->st->codec->codec_type) {
2fef0bdf 1110 case CODEC_TYPE_AUDIO:
115329f1 1111 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
01f4895c 1112 (ist->st->codec->sample_rate * ist->st->codec->channels);
2fef0bdf
MN
1113 break;
1114 case CODEC_TYPE_VIDEO:
01f4895c 1115 if (ist->st->codec->time_base.num != 0) {
115329f1 1116 ist->next_pts += ((int64_t)AV_TIME_BASE *
01f4895c
MN
1117 ist->st->codec->time_base.num) /
1118 ist->st->codec->time_base.den;
2fef0bdf
MN
1119 }
1120 break;
1121 }
a700a6ae
FB
1122 data_buf = ptr;
1123 data_size = len;
1124 ret = len;
1125 len = 0;
1126 }
1127
1128 buffer_to_free = NULL;
01f4895c 1129 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
115329f1 1130 pre_process_video_frame(ist, (AVPicture *)&picture,
a700a6ae
FB
1131 &buffer_to_free);
1132 }
1133
7e987c33 1134 // preprocess audio (volume)
01f4895c 1135 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
a9aa3467 1136 if (audio_volume != 256) {
7e987c33 1137 short *volp;
7e987c33
C
1138 volp = samples;
1139 for(i=0;i<(data_size / sizeof(short));i++) {
a9aa3467 1140 int v = ((*volp) * audio_volume + 128) >> 8;
7e987c33
C
1141 if (v < -32768) v = -32768;
1142 if (v > 32767) v = 32767;
1143 *volp++ = v;
1144 }
1145 }
1146 }
1147
a700a6ae 1148 /* frame rate emulation */
01f4895c
MN
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);
a700a6ae
FB
1151 int64_t now = av_gettime() - ist->start;
1152 if (pts > now)
1153 usleep(pts - now);
1154
1155 ist->frame++;
1156 }
1157
1158#if 0
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 ? */
01f4895c
MN
1162 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1163 if (ist->st->codec->pict_type != B_TYPE) {
a700a6ae
FB
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;
1168 }
1169 }
1170#endif
115329f1 1171 /* if output time reached then transcode raw format,
bb270c08 1172 encode packets and output them */
a700a6ae
FB
1173 if (start_time == 0 || ist->pts >= start_time)
1174 for(i=0;i<nb_ostreams;i++) {
1175 int frame_size;
1176
1177 ost = ost_table[i];
1178 if (ost->source_index == ist_index) {
1179 os = output_files[ost->file_index];
1180
1181#if 0
115329f1
DB
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) -
986ebcdb 1185 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
a700a6ae
FB
1186#endif
1187 /* set the input output pts pairs */
b4a3389e 1188 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
a700a6ae
FB
1189
1190 if (ost->encoding_needed) {
01f4895c 1191 switch(ost->st->codec->codec_type) {
a700a6ae
FB
1192 case CODEC_TYPE_AUDIO:
1193 do_audio_out(os, ost, ist, data_buf, data_size);
1194 break;
1195 case CODEC_TYPE_VIDEO:
986ebcdb 1196 do_video_out(os, ost, ist, &picture, &frame_size);
1008ceb3 1197 video_size += frame_size;
a700a6ae
FB
1198 if (do_vstats && frame_size)
1199 do_video_stats(os, ost, frame_size);
a700a6ae 1200 break;
cf7fc795
FB
1201 case CODEC_TYPE_SUBTITLE:
1202 do_subtitle_out(os, ost, ist, &subtitle,
1203 pkt->pts);
1204 break;
a700a6ae
FB
1205 default:
1206 av_abort();
1207 }
1208 } else {
e928649b
MN
1209 AVFrame avframe; //FIXME/XXX remove this
1210 AVPacket opkt;
1211 av_init_packet(&opkt);
1212
a700a6ae
FB
1213 /* no reencoding needed : output the packet directly */
1214 /* force the input stream PTS */
115329f1 1215
9740beff 1216 avcodec_get_frame_defaults(&avframe);
01f4895c 1217 ost->st->codec->coded_frame= &avframe;
115329f1 1218 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
bf17ff61 1219
01f4895c 1220 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
c7baf14b 1221 audio_size += data_size;
01f4895c 1222 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
c7baf14b 1223 video_size += data_size;
daed32f7
WG
1224 ost->sync_opts++;
1225 }
c7baf14b 1226
e928649b 1227 opkt.stream_index= ost->index;
6c55b27f 1228 if(pkt->pts != AV_NOPTS_VALUE)
c0df9d75 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);
6c55b27f
MN
1230 else
1231 opkt.pts= AV_NOPTS_VALUE;
cf7fc795
FB
1232
1233 {
1234 int64_t dts;
1235 if (pkt->dts == AV_NOPTS_VALUE)
1236 dts = ist->next_pts;
1237 else
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);
1240 }
e928649b 1241 opkt.flags= pkt->flags;
748c2fca
MN
1242
1243 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
01f4895c 1244 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
90ad92b3 1245 opkt.destruct= av_destruct_packet;
748c2fca
MN
1246
1247 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
01f4895c 1248 ost->st->codec->frame_number++;
a700a6ae 1249 ost->frame_number++;
90ad92b3 1250 av_free_packet(&opkt);
a700a6ae
FB
1251 }
1252 }
1253 }
1254 av_free(buffer_to_free);
cf7fc795
FB
1255 /* XXX: allocate the subtitles in the codec ? */
1256 if (subtitle_to_free) {
c6ec28b1
MN
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);
1261 }
1262 av_freep(&subtitle_to_free->rects);
1263 }
1264 subtitle_to_free->num_rects = 0;
cf7fc795
FB
1265 subtitle_to_free = NULL;
1266 }
a700a6ae
FB
1267 }
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;
51bd4565 1356 AVFormatContext *stream_no_data;
cb09b2ed 1357 int key;
bdc4796f 1358
51bd4565 1359 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
bdc4796f
FB
1360 if (!file_table)
1361 goto fail;
115329f1 1362
85f07f22
FB
1363 /* input stream init */
1364 j = 0;
1365 for(i=0;i<nb_input_files;i++) {
1366 is = input_files[i];
1367 file_table[i].ist_index = j;
79fdaa4c 1368 file_table[i].nb_streams = is->nb_streams;
85f07f22
FB
1369 j += is->nb_streams;
1370 }
1371 nb_istreams = j;
1372
1373 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1374 if (!ist_table)
bdc4796f 1375 goto fail;
115329f1 1376
85f07f22
FB
1377 for(i=0;i<nb_istreams;i++) {
1378 ist = av_mallocz(sizeof(AVInputStream));
1379 if (!ist)
1380 goto fail;
1381 ist_table[i] = ist;
1382 }
1383 j = 0;
1384 for(i=0;i<nb_input_files;i++) {
1385 is = input_files[i];
1386 for(k=0;k<is->nb_streams;k++) {
1387 ist = ist_table[j++];
1388 ist->st = is->streams[k];
1389 ist->file_index = i;
1390 ist->index = k;
1391 ist->discard = 1; /* the stream is discarded by default
1392 (changed later) */
bdfcbbed 1393
01f4895c 1394 if (ist->st->codec->rate_emu) {
bdfcbbed
MK
1395 ist->start = av_gettime();
1396 ist->frame = 0;
1397 }
85f07f22
FB
1398 }
1399 }
1400
1401 /* output stream init */
1402 nb_ostreams = 0;
1403 for(i=0;i<nb_output_files;i++) {
1404 os = output_files[i];
8a7bde1c
BC
1405 if (!os->nb_streams) {
1406 fprintf(stderr, "Output file does not contain any stream\n");
1407 exit(1);
1408 }
85f07f22
FB
1409 nb_ostreams += os->nb_streams;
1410 }
1411 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1412 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1413 exit(1);
1414 }
1415
bd073980
BF
1416 /* Sanity check the mapping args -- do the input files & streams exist? */
1417 for(i=0;i<nb_stream_maps;i++) {
1418 int fi = stream_maps[i].file_index;
1419 int si = stream_maps[i].stream_index;
115329f1 1420
bd073980
BF
1421 if (fi < 0 || fi > nb_input_files - 1 ||
1422 si < 0 || si > file_table[fi].nb_streams - 1) {
1423 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1424 exit(1);
1425 }
b4a3389e
WG
1426 fi = stream_maps[i].sync_file_index;
1427 si = stream_maps[i].sync_stream_index;
1428 if (fi < 0 || fi > nb_input_files - 1 ||
1429 si < 0 || si > file_table[fi].nb_streams - 1) {
1430 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1431 exit(1);
1432 }
bd073980 1433 }
115329f1 1434
85f07f22
FB
1435 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1436 if (!ost_table)
1437 goto fail;
1438 for(i=0;i<nb_ostreams;i++) {
1439 ost = av_mallocz(sizeof(AVOutputStream));
1440 if (!ost)
1441 goto fail;
1442 ost_table[i] = ost;
1443 }
115329f1 1444
85f07f22
FB
1445 n = 0;
1446 for(k=0;k<nb_output_files;k++) {
1447 os = output_files[k];
1448 for(i=0;i<os->nb_streams;i++) {
1449 int found;
1450 ost = ost_table[n++];
1451 ost->file_index = k;
1452 ost->index = i;
1453 ost->st = os->streams[i];
1454 if (nb_stream_maps > 0) {
115329f1 1455 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
85f07f22 1456 stream_maps[n-1].stream_index;
115329f1 1457
bd073980 1458 /* Sanity check that the stream types match */
01f4895c 1459 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
bd073980
BF
1460 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1461 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1462 ost->file_index, ost->index);
1463 exit(1);
1464 }
115329f1 1465
85f07f22
FB
1466 } else {
1467 /* get corresponding input stream index : we select the first one with the right type */
1468 found = 0;
1469 for(j=0;j<nb_istreams;j++) {
1470 ist = ist_table[j];
115329f1 1471 if (ist->discard &&
01f4895c 1472 ist->st->codec->codec_type == ost->st->codec->codec_type) {
85f07f22
FB
1473 ost->source_index = j;
1474 found = 1;
c19e76ce 1475 break;
85f07f22
FB
1476 }
1477 }
115329f1 1478
85f07f22
FB
1479 if (!found) {
1480 /* try again and reuse existing stream */
1481 for(j=0;j<nb_istreams;j++) {
1482 ist = ist_table[j];
01f4895c 1483 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
85f07f22
FB
1484 ost->source_index = j;
1485 found = 1;
1486 }
1487 }
1488 if (!found) {
1489 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1490 ost->file_index, ost->index);
1491 exit(1);
1492 }
1493 }
1494 }
1495 ist = ist_table[ost->source_index];
1496 ist->discard = 0;
b4a3389e
WG
1497 ost->sync_ist = (nb_stream_maps > 0) ?
1498 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1499 stream_maps[n-1].sync_stream_index] : ist;
85f07f22
FB
1500 }
1501 }
1502
85f07f22
FB
1503 /* for each output stream, we compute the right encoding parameters */
1504 for(i=0;i<nb_ostreams;i++) {
1505 ost = ost_table[i];
1506 ist = ist_table[ost->source_index];
1507
01f4895c
MN
1508 codec = ost->st->codec;
1509 icodec = ist->st->codec;
85f07f22 1510
1629626f
FB
1511 if (ost->st->stream_copy) {
1512 /* if stream_copy is selected, no need to decode or encode */
1513 codec->codec_id = icodec->codec_id;
1514 codec->codec_type = icodec->codec_type;
b2a2197e 1515 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1629626f 1516 codec->bit_rate = icodec->bit_rate;
dffbfd06
MN
1517 codec->extradata= icodec->extradata;
1518 codec->extradata_size= icodec->extradata_size;
4408e75e 1519 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
d29de719
MN
1520 codec->time_base = icodec->time_base;
1521 else
1522 codec->time_base = ist->st->time_base;
1629626f
FB
1523 switch(codec->codec_type) {
1524 case CODEC_TYPE_AUDIO:
1525 codec->sample_rate = icodec->sample_rate;
1526 codec->channels = icodec->channels;
0a3b0447 1527 codec->frame_size = icodec->frame_size;
c1344911 1528 codec->block_align= icodec->block_align;
1629626f
FB
1529 break;
1530 case CODEC_TYPE_VIDEO:
8d74e55b
MD
1531 if(using_vhook) {
1532 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1533 exit(1);
1534 }
9df3437f 1535 codec->pix_fmt = icodec->pix_fmt;
1629626f
FB
1536 codec->width = icodec->width;
1537 codec->height = icodec->height;
ff8cc24b 1538 codec->has_b_frames = icodec->has_b_frames;
1629626f 1539 break;
cf7fc795
FB
1540 case CODEC_TYPE_SUBTITLE:
1541 break;
1629626f
FB
1542 default:
1543 av_abort();
1544 }
1545 } else {
1546 switch(codec->codec_type) {
1547 case CODEC_TYPE_AUDIO:
f5a478f6 1548 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
85f07f22 1549 goto fail;
115329f1 1550
85f07f22
FB
1551 if (codec->channels == icodec->channels &&
1552 codec->sample_rate == icodec->sample_rate) {
1553 ost->audio_resample = 0;
1554 } else {
e0d2714a 1555 if (codec->channels != icodec->channels &&
23c99253
MN
1556 (icodec->codec_id == CODEC_ID_AC3 ||
1557 icodec->codec_id == CODEC_ID_DTS)) {
1558 /* Special case for 5:1 AC3 and DTS input */
e0d2714a 1559 /* and mono or stereo output */
6dc96cb0
J
1560 /* Request specific number of channels */
1561 icodec->channels = codec->channels;
1562 if (codec->sample_rate == icodec->sample_rate)
1563 ost->audio_resample = 0;
1564 else {
1565 ost->audio_resample = 1;
6dc96cb0 1566 }
e0d2714a 1567 } else {
115329f1 1568 ost->audio_resample = 1;
986ebcdb
MN
1569 }
1570 }
ff4905a5 1571 if(audio_sync_method>1)
986ebcdb
MN
1572 ost->audio_resample = 1;
1573
1574 if(ost->audio_resample){
1575 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1576 codec->sample_rate, icodec->sample_rate);
1577 if(!ost->resample){
1578 printf("Can't resample. Aborting.\n");
1579 av_abort();
e0d2714a 1580 }
85f07f22
FB
1581 }
1582 ist->decoding_needed = 1;
1583 ost->encoding_needed = 1;
1629626f
FB
1584 break;
1585 case CODEC_TYPE_VIDEO:
c3f11d19
LA
1586 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1587 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1588 ost->video_resample = ((codec->width != icodec->width -
1589 (frame_leftBand + frame_rightBand) +
1590 (frame_padleft + frame_padright)) ||
1591 (codec->height != icodec->height -
1592 (frame_topBand + frame_bottomBand) +
18a54b04
LA
1593 (frame_padtop + frame_padbottom)) ||
1594 (codec->pix_fmt != icodec->pix_fmt));
c3f11d19 1595 if (ost->video_crop) {
34b10a57
D
1596 ost->topBand = frame_topBand;
1597 ost->leftBand = frame_leftBand;
c3f11d19
LA
1598 }
1599 if (ost->video_pad) {
1ff93ffc
TK
1600 ost->padtop = frame_padtop;
1601 ost->padleft = frame_padleft;
1602 ost->padbottom = frame_padbottom;
1603 ost->padright = frame_padright;
c3f11d19
LA
1604 if (!ost->video_resample) {
1605 avcodec_get_frame_defaults(&ost->pict_tmp);
1606 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1607 codec->width, codec->height ) )
1608 goto fail;
1609 }
1610 }
1611 if (ost->video_resample) {
2de28abb 1612 avcodec_get_frame_defaults(&ost->pict_tmp);
18a54b04 1613 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2caa92d9 1614 codec->width, codec->height ) )
7a168618 1615 exit(1);
85f07f22 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
85f07f22
FB
1771 /* compute buffer size max (should use a complete heuristic) */
1772 for(i=0;i<nb_input_files;i++) {
1773 file_table[i].buffer_size_max = 2048;
1774 }
1775
0a38bafd
PB
1776 /* set meta data information from input file if required */
1777 for (i=0;i<nb_meta_data_maps;i++) {
1778 AVFormatContext *out_file;
1779 AVFormatContext *in_file;
1780
1781 int out_file_index = meta_data_maps[i].out_file;
1782 int in_file_index = meta_data_maps[i].in_file;
1783 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1784 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
8fa36ae0 1785 ret = AVERROR(EINVAL);
0a38bafd
PB
1786 goto fail;
1787 }
1788 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1789 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
8fa36ae0 1790 ret = AVERROR(EINVAL);
0a38bafd 1791 goto fail;
115329f1
DB
1792 }
1793
0a38bafd
PB
1794 out_file = output_files[out_file_index];
1795 in_file = input_files[in_file_index];
1796
1797 strcpy(out_file->title, in_file->title);
1798 strcpy(out_file->author, in_file->author);
1799 strcpy(out_file->copyright, in_file->copyright);
1800 strcpy(out_file->comment, in_file->comment);
1801 strcpy(out_file->album, in_file->album);
1802 out_file->year = in_file->year;
1803 out_file->track = in_file->track;
1804 strcpy(out_file->genre, in_file->genre);
1805 }
115329f1 1806
85f07f22
FB
1807 /* open files and write file headers */
1808 for(i=0;i<nb_output_files;i++) {
1809 os = output_files[i];
79fdaa4c 1810 if (av_write_header(os) < 0) {
65bf3c53 1811 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
8fa36ae0 1812 ret = AVERROR(EINVAL);
a38469e1
FB
1813 goto fail;
1814 }
85f07f22
FB
1815 }
1816
d8019eb5 1817 if ( !using_stdin && verbose >= 0) {
d9a916e2 1818 fprintf(stderr, "Press [q] to stop encoding\n");
b51469a0
LS
1819 url_set_interrupt_cb(decode_interrupt_cb);
1820 }
a38469e1
FB
1821 term_init();
1822
51bd4565 1823 stream_no_data = 0;
cb09b2ed 1824 key = -1;
51bd4565 1825
d9a916e2 1826 for(; received_sigterm == 0;) {
85f07f22
FB
1827 int file_index, ist_index;
1828 AVPacket pkt;
a9aeda81
PB
1829 double ipts_min;
1830 double opts_min;
23ffe323 1831
85f07f22 1832 redo:
a9aeda81
PB
1833 ipts_min= 1e100;
1834 opts_min= 1e100;
a38469e1 1835 /* if 'q' pressed, exits */
d9a916e2 1836 if (!using_stdin) {
b51469a0
LS
1837 if (q_pressed)
1838 break;
cb09b2ed
PG
1839 /* read_key() returns 0 on EOF */
1840 key = read_key();
1841 if (key == 'q')
1842 break;
1843 }
a38469e1 1844
ec5517d5
FB
1845 /* select the stream that we must read now by looking at the
1846 smallest output pts */
85f07f22 1847 file_index = -1;
ec5517d5 1848 for(i=0;i<nb_ostreams;i++) {
23ffe323 1849 double ipts, opts;
ec5517d5
FB
1850 ost = ost_table[i];
1851 os = output_files[ost->file_index];
1852 ist = ist_table[ost->source_index];
01f4895c
MN
1853 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1854 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
23ffe323 1855 else
c0df9d75 1856 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
23ffe323
MN
1857 ipts = (double)ist->pts;
1858 if (!file_table[ist->file_index].eof_reached){
1859 if(ipts < ipts_min) {
1860 ipts_min = ipts;
1861 if(input_sync ) file_index = ist->file_index;
1862 }
1863 if(opts < opts_min) {
1864 opts_min = opts;
1865 if(!input_sync) file_index = ist->file_index;
1866 }
85f07f22 1867 }
01f4895c 1868 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
7ca60994
MN
1869 file_index= -1;
1870 break;
1871 }
85f07f22
FB
1872 }
1873 /* if none, if is finished */
51bd4565 1874 if (file_index < 0) {
85f07f22 1875 break;
ec5517d5
FB
1876 }
1877
85f07f22 1878 /* finish if recording time exhausted */
23ffe323 1879 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
85f07f22 1880 break;
ec5517d5 1881
b6e16b86
C
1882 /* finish if limit size exhausted */
1883 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1884 break;
1885
254abc2e 1886 /* read a frame from it and output it in the fifo */
85f07f22 1887 is = input_files[file_index];
254abc2e 1888 if (av_read_frame(is, &pkt) < 0) {
85f07f22 1889 file_table[file_index].eof_reached = 1;
ca80810b 1890 if (opt_shortest) break; else continue; //
85f07f22 1891 }
303e50e6 1892
51bd4565
PG
1893 if (!pkt.size) {
1894 stream_no_data = is;
1895 } else {
1896 stream_no_data = 0;
1897 }
254abc2e
FB
1898 if (do_pkt_dump) {
1899 av_pkt_dump(stdout, &pkt, do_hex_dump);
817b23ff 1900 }
79fdaa4c
FB
1901 /* the following test is needed in case new streams appear
1902 dynamically in stream : we ignore them */
1903 if (pkt.stream_index >= file_table[file_index].nb_streams)
bf5af568 1904 goto discard_packet;
85f07f22
FB
1905 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1906 ist = ist_table[ist_index];
bf5af568
FB
1907 if (ist->discard)
1908 goto discard_packet;
85f07f22 1909
949b1a13 1910// 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 1911 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
c0df9d75 1912 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
c26abfa5 1913 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
72bd8100
MN
1914 input_files_ts_offset[ist->file_index]-= delta;
1915 if (verbose > 2)
4733abcb 1916 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
72bd8100
MN
1917 for(i=0; i<file_table[file_index].nb_streams; i++){
1918 int index= file_table[file_index].ist_index + i;
1919 ist_table[index]->next_pts += delta;
ff4905a5 1920 ist_table[index]->is_start=1;
72bd8100
MN
1921 }
1922 }
1923 }
1924
8831db5c 1925 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
a700a6ae 1926 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
d8019eb5
AD
1927
1928 if (verbose >= 0)
1929 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1930 ist->file_index, ist->index);
1931
a700a6ae
FB
1932 av_free_packet(&pkt);
1933 goto redo;
fe08925f 1934 }
cf7fc795 1935
bf5af568 1936 discard_packet:
85f07f22 1937 av_free_packet(&pkt);
115329f1 1938
ec5517d5
FB
1939 /* dump report by using the output first video and audio streams */
1940 print_report(output_files, ost_table, nb_ostreams, 0);
85f07f22 1941 }
a700a6ae
FB
1942
1943 /* at the end of stream, we must flush the decoder buffers */
1944 for(i=0;i<nb_istreams;i++) {
1945 ist = ist_table[i];
1946 if (ist->decoding_needed) {
1947 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1948 }
1949 }
1950
a38469e1 1951 term_exit();
85f07f22 1952
c4e37247
MN
1953 /* write the trailer if needed and close file */
1954 for(i=0;i<nb_output_files;i++) {
1955 os = output_files[i];
1956 av_write_trailer(os);
1957 }
1958
37f5cd5a
MN
1959 /* dump report by using the first video and audio streams */
1960 print_report(output_files, ost_table, nb_ostreams, 1);
1961
85f07f22
FB
1962 /* close each encoder */
1963 for(i=0;i<nb_ostreams;i++) {
1964 ost = ost_table[i];
1965 if (ost->encoding_needed) {
01f4895c
MN
1966 av_freep(&ost->st->codec->stats_in);
1967 avcodec_close(ost->st->codec);
85f07f22
FB
1968 }
1969 }
115329f1 1970
85f07f22
FB
1971 /* close each decoder */
1972 for(i=0;i<nb_istreams;i++) {
1973 ist = ist_table[i];
1974 if (ist->decoding_needed) {
01f4895c 1975 avcodec_close(ist->st->codec);
85f07f22
FB
1976 }
1977 }
85f07f22 1978
85f07f22 1979 /* finished ! */
115329f1 1980
85f07f22
FB
1981 ret = 0;
1982 fail1:
83b07470 1983 av_freep(&bit_buffer);
0f1578af 1984 av_free(file_table);
bdc4796f 1985
85f07f22
FB
1986 if (ist_table) {
1987 for(i=0;i<nb_istreams;i++) {
1988 ist = ist_table[i];
0f1578af 1989 av_free(ist);
85f07f22 1990 }
0f1578af 1991 av_free(ist_table);
85f07f22
FB
1992 }
1993 if (ost_table) {
1994 for(i=0;i<nb_ostreams;i++) {
1995 ost = ost_table[i];
1996 if (ost) {
5abdb4b1
FB
1997 if (ost->logfile) {
1998 fclose(ost->logfile);
1999 ost->logfile = NULL;
2000 }
f5a478f6
RS
2001 av_fifo_free(&ost->fifo); /* works even if fifo is not
2002 initialized but set to zero */
0f1578af 2003 av_free(ost->pict_tmp.data[0]);
85f07f22 2004 if (ost->video_resample)
18a54b04 2005 sws_freeContext(ost->img_resample_ctx);
85f07f22
FB
2006 if (ost->audio_resample)
2007 audio_resample_close(ost->resample);
0f1578af 2008 av_free(ost);
85f07f22
FB
2009 }
2010 }
0f1578af 2011 av_free(ost_table);
85f07f22
FB
2012 }
2013 return ret;
2014 fail:
8fa36ae0 2015 ret = AVERROR(ENOMEM);
85f07f22
FB
2016 goto fail1;
2017}
2018
2019#if 0
2020int file_read(const char *filename)
2021{
2022 URLContext *h;
2023 unsigned char buffer[1024];
2024 int len, i;
2025
2026 if (url_open(&h, filename, O_RDONLY) < 0) {
2027 printf("could not open '%s'\n", filename);
2028 return -1;
2029 }
2030 for(;;) {
2031 len = url_read(h, buffer, sizeof(buffer));
2032 if (len <= 0)
2033 break;
2034 for(i=0;i<len;i++) putchar(buffer[i]);
2035 }
2036 url_close(h);
2037 return 0;
2038}
2039#endif
2040
b29f97d1 2041static void opt_format(const char *arg)
85f07f22 2042{
817b23ff
FB
2043 /* compatibility stuff for pgmyuv */
2044 if (!strcmp(arg, "pgmyuv")) {
5b6d5596 2045 pgmyuv_compatibility_hack=1;
9286699a 2046// opt_image_format(arg);
5b6d5596 2047 arg = "image2";
817b23ff
FB
2048 }
2049
79fdaa4c
FB
2050 file_iformat = av_find_input_format(arg);
2051 file_oformat = guess_format(arg, NULL, NULL);
2052 if (!file_iformat && !file_oformat) {
2053 fprintf(stderr, "Unknown input or output format: %s\n", arg);
85f07f22
FB
2054 exit(1);
2055 }
85f07f22
FB
2056}
2057
b29f97d1 2058static void opt_video_rc_eq(char *arg)
3aa102be
MN
2059{
2060 video_rc_eq = arg;
2061}
2062
b29f97d1 2063static void opt_video_rc_override_string(char *arg)
ac2830ec
MN
2064{
2065 video_rc_override_string = arg;
2066}
2067
f4f3223f
MN
2068static void opt_me_threshold(const char *arg)
2069{
2070 me_threshold = atoi(arg);
2071}
2072
f068206e
BE
2073static void opt_verbose(const char *arg)
2074{
2075 verbose = atoi(arg);
ab1c6dc9 2076 av_log_level = atoi(arg);
f068206e
BE
2077}
2078
b29f97d1 2079static void opt_frame_rate(const char *arg)
85f07f22 2080{
445f1b83
RS
2081 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2082 fprintf(stderr, "Incorrect frame rate\n");
bb270c08 2083 exit(1);
445f1b83 2084 }
85f07f22
FB
2085}
2086
b29f97d1 2087static void opt_frame_crop_top(const char *arg)
ab6d194a 2088{
115329f1 2089 frame_topBand = atoi(arg);
ab6d194a
MN
2090 if (frame_topBand < 0) {
2091 fprintf(stderr, "Incorrect top crop size\n");
2092 exit(1);
2093 }
2094 if ((frame_topBand % 2) != 0) {
2095 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2096 exit(1);
2097 }
2098 if ((frame_topBand) >= frame_height){
bb270c08 2099 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2100 exit(1);
2101 }
2102 frame_height -= frame_topBand;
2103}
2104
b29f97d1 2105static void opt_frame_crop_bottom(const char *arg)
ab6d194a
MN
2106{
2107 frame_bottomBand = atoi(arg);
2108 if (frame_bottomBand < 0) {
2109 fprintf(stderr, "Incorrect bottom crop size\n");
2110 exit(1);
2111 }
2112 if ((frame_bottomBand % 2) != 0) {
2113 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
115329f1 2114 exit(1);
ab6d194a
MN
2115 }
2116 if ((frame_bottomBand) >= frame_height){
bb270c08 2117 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2118 exit(1);
2119 }
2120 frame_height -= frame_bottomBand;
2121}
2122
b29f97d1 2123static void opt_frame_crop_left(const char *arg)
ab6d194a
MN
2124{
2125 frame_leftBand = atoi(arg);
2126 if (frame_leftBand < 0) {
2127 fprintf(stderr, "Incorrect left crop size\n");
2128 exit(1);
2129 }
2130 if ((frame_leftBand % 2) != 0) {
2131 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2132 exit(1);
2133 }
2134 if ((frame_leftBand) >= frame_width){
bb270c08 2135 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2136 exit(1);
2137 }
2138 frame_width -= frame_leftBand;
2139}
2140
b29f97d1 2141static void opt_frame_crop_right(const char *arg)
ab6d194a
MN
2142{
2143 frame_rightBand = atoi(arg);
2144 if (frame_rightBand < 0) {
2145 fprintf(stderr, "Incorrect right crop size\n");
2146 exit(1);
2147 }
2148 if ((frame_rightBand % 2) != 0) {
2149 fprintf(stderr, "Right crop size must be a multiple of 2\n");
115329f1 2150 exit(1);
ab6d194a
MN
2151 }
2152 if ((frame_rightBand) >= frame_width){
bb270c08 2153 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
ab6d194a
MN
2154 exit(1);
2155 }
2156 frame_width -= frame_rightBand;
2157}
2158
b29f97d1 2159static void opt_frame_size(const char *arg)
85f07f22 2160{
445f1b83 2161 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
85f07f22
FB
2162 fprintf(stderr, "Incorrect frame size\n");
2163 exit(1);
2164 }
2165 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2166 fprintf(stderr, "Frame size must be a multiple of 2\n");
2167 exit(1);
2168 }
2169}
2170
1ff93ffc
TK
2171
2172#define SCALEBITS 10
2173#define ONE_HALF (1 << (SCALEBITS - 1))
bb270c08 2174#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
1ff93ffc
TK
2175
2176#define RGB_TO_Y(r, g, b) \
2177((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2178 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2179
2180#define RGB_TO_U(r1, g1, b1, shift)\
2181(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2182 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2183
2184#define RGB_TO_V(r1, g1, b1, shift)\
2185(((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2186 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2187
2188static void opt_pad_color(const char *arg) {
2189 /* Input is expected to be six hex digits similar to
2190 how colors are expressed in html tags (but without the #) */
2191 int rgb = strtol(arg, NULL, 16);
2192 int r,g,b;
115329f1
DB
2193
2194 r = (rgb >> 16);
1ff93ffc
TK
2195 g = ((rgb >> 8) & 255);
2196 b = (rgb & 255);
2197
2198 padcolor[0] = RGB_TO_Y(r,g,b);
2199 padcolor[1] = RGB_TO_U(r,g,b,0);
2200 padcolor[2] = RGB_TO_V(r,g,b,0);
2201}
2202
2203static void opt_frame_pad_top(const char *arg)
2204{
115329f1 2205 frame_padtop = atoi(arg);
1ff93ffc
TK
2206 if (frame_padtop < 0) {
2207 fprintf(stderr, "Incorrect top pad size\n");
2208 exit(1);
2209 }
2210 if ((frame_padtop % 2) != 0) {
2211 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2212 exit(1);
2213 }
2214}
2215
2216static void opt_frame_pad_bottom(const char *arg)
2217{
115329f1 2218 frame_padbottom = atoi(arg);
1ff93ffc
TK
2219 if (frame_padbottom < 0) {
2220 fprintf(stderr, "Incorrect bottom pad size\n");
2221 exit(1);
2222 }
2223 if ((frame_padbottom % 2) != 0) {
2224 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2225 exit(1);
2226 }
2227}
2228
2229
2230static void opt_frame_pad_left(const char *arg)
2231{
115329f1 2232 frame_padleft = atoi(arg);
1ff93ffc
TK
2233 if (frame_padleft < 0) {
2234 fprintf(stderr, "Incorrect left pad size\n");
2235 exit(1);
2236 }
2237 if ((frame_padleft % 2) != 0) {
2238 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2239 exit(1);
2240 }
2241}
2242
2243
2244static void opt_frame_pad_right(const char *arg)
2245{
115329f1 2246 frame_padright = atoi(arg);
1ff93ffc
TK
2247 if (frame_padright < 0) {
2248 fprintf(stderr, "Incorrect right pad size\n");
2249 exit(1);
2250 }
2251 if ((frame_padright % 2) != 0) {
2252 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2253 exit(1);
2254 }
2255}
2256
2257
63167088
RS
2258static void opt_frame_pix_fmt(const char *arg)
2259{
2260 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2261}
2262
5fe03e38
RS
2263static void opt_frame_aspect_ratio(const char *arg)
2264{
2265 int x = 0, y = 0;
2266 double ar = 0;
2267 const char *p;
115329f1 2268
5fe03e38
RS
2269 p = strchr(arg, ':');
2270 if (p) {
2271 x = strtol(arg, (char **)&arg, 10);
bb270c08
DB
2272 if (arg == p)
2273 y = strtol(arg+1, (char **)&arg, 10);
2274 if (x > 0 && y > 0)
2275 ar = (double)x / (double)y;
5fe03e38
RS
2276 } else
2277 ar = strtod(arg, (char **)&arg);
2278
2279 if (!ar) {
2280 fprintf(stderr, "Incorrect aspect ratio specification.\n");
bb270c08 2281 exit(1);
5fe03e38
RS
2282 }
2283 frame_aspect_ratio = ar;
2284}
2285
b29f97d1 2286static void opt_qscale(const char *arg)
85f07f22 2287{
158c7f05 2288 video_qscale = atof(arg);
4e64bead 2289 if (video_qscale <= 0 ||
158c7f05 2290 video_qscale > 255) {
4e64bead 2291 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
85f07f22
FB
2292 exit(1);
2293 }
2294}
2295
b29f97d1 2296static void opt_qdiff(const char *arg)
9cdd6a24
MN
2297{
2298 video_qdiff = atoi(arg);
2299 if (video_qdiff < 0 ||
2300 video_qdiff > 31) {
2301 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2302 exit(1);
2303 }
2304}
2305
b29f97d1 2306static void opt_strict(const char *arg)
f560dd82
MN
2307{
2308 strict= atoi(arg);
2309}
2310
bb198e19
MN
2311static void opt_top_field_first(const char *arg)
2312{
2313 top_field_first= atoi(arg);
2314}
2315
9c3d33d6
MN
2316static void opt_thread_count(const char *arg)
2317{
2318 thread_count= atoi(arg);
2450cff2 2319#if !defined(HAVE_THREADS)
d8019eb5
AD
2320 if (verbose >= 0)
2321 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
842b556a 2322#endif
9c3d33d6
MN
2323}
2324
b29f97d1 2325static void opt_audio_rate(const char *arg)
85f07f22
FB
2326{
2327 audio_sample_rate = atoi(arg);
2328}
2329
b29f97d1 2330static void opt_audio_channels(const char *arg)
85f07f22
FB
2331{
2332 audio_channels = atoi(arg);
2333}
2334
b29f97d1 2335static void opt_video_channel(const char *arg)
a5df11ab
FB
2336{
2337 video_channel = strtol(arg, NULL, 0);
2338}
2339
e3ee3283
AB
2340static void opt_video_standard(const char *arg)
2341{
2342 video_standard = av_strdup(arg);
2343}
2344
cf7fc795
FB
2345static void opt_codec(int *pstream_copy, int *pcodec_id,
2346 int codec_type, const char *arg)
85f07f22
FB
2347{
2348 AVCodec *p;
2349
1629626f 2350 if (!strcmp(arg, "copy")) {
cf7fc795 2351 *pstream_copy = 1;
85f07f22 2352 } else {
1629626f
FB
2353 p = first_avcodec;
2354 while (p) {
cf7fc795 2355 if (!strcmp(p->name, arg) && p->type == codec_type)
1629626f
FB
2356 break;
2357 p = p->next;
2358 }
2359 if (p == NULL) {
cf7fc795 2360 fprintf(stderr, "Unknown codec '%s'\n", arg);
1629626f
FB
2361 exit(1);
2362 } else {
cf7fc795 2363 *pcodec_id = p->id;
1629626f 2364 }
85f07f22
FB
2365 }
2366}
2367
cf7fc795
FB
2368static void opt_audio_codec(const char *arg)
2369{
2370 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2371}
2372
b2a2197e
MN
2373static void opt_audio_tag(const char *arg)
2374{
2375 char *tail;
2376 audio_codec_tag= strtol(arg, &tail, 0);
2377
2378 if(!tail || *tail)
2379 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2380}
2381
2382static void opt_video_tag(const char *arg)
2383{
2384 char *tail;
2385 video_codec_tag= strtol(arg, &tail, 0);
2386
2387 if(!tail || *tail)
2388 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2389}
2390
b29f97d1 2391static void add_frame_hooker(const char *arg)
10d104e4
PG
2392{
2393 int argc = 0;
2394 char *argv[64];
2395 int i;
e9a9e0c2 2396 char *args = av_strdup(arg);
10d104e4 2397
bee0d9e5
CY
2398 using_vhook = 1;
2399
10d104e4
PG
2400 argv[0] = strtok(args, " ");
2401 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2402 }
2403
2404 i = frame_hook_add(argc, argv);
2405
2406 if (i != 0) {
2407 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2408 exit(1);
2409 }
2410}
2411
85f07f22
FB
2412const char *motion_str[] = {
2413 "zero",
2414 "full",
2415 "log",
2416 "phods",
7084c149
MN
2417 "epzs",
2418 "x1",
51d6a3cf
MN
2419 "hex",
2420 "umh",
2421 "iter",
85f07f22
FB
2422 NULL,
2423};
2424
b29f97d1 2425static void opt_motion_estimation(const char *arg)
85f07f22
FB
2426{
2427 const char **p;
2428 p = motion_str;
2429 for(;;) {
2430 if (!*p) {
2431 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2432 exit(1);
2433 }
2434 if (!strcmp(*p, arg))
2435 break;
2436 p++;
2437 }
101bea5f 2438 me_method = (p - motion_str) + 1;
85f07f22
FB
2439}
2440
b29f97d1 2441static void opt_video_codec(const char *arg)
85f07f22 2442{
cf7fc795
FB
2443 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2444}
85f07f22 2445
cf7fc795
FB
2446static void opt_subtitle_codec(const char *arg)
2447{
2448 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
85f07f22
FB
2449}
2450
b29f97d1 2451static void opt_map(const char *arg)
85f07f22
FB
2452{
2453 AVStreamMap *m;
2454 const char *p;
2455
2456 p = arg;
2457 m = &stream_maps[nb_stream_maps++];
2458
2459 m->file_index = strtol(arg, (char **)&p, 0);
2460 if (*p)
2461 p++;
a5dc85ef
J
2462
2463 m->stream_index = strtol(p, (char **)&p, 0);
b4a3389e
WG
2464 if (*p) {
2465 p++;
2466 m->sync_file_index = strtol(p, (char **)&p, 0);
2467 if (*p)
2468 p++;
2469 m->sync_stream_index = strtol(p, (char **)&p, 0);
2470 } else {
2471 m->sync_file_index = m->file_index;
2472 m->sync_stream_index = m->stream_index;
2473 }
85f07f22
FB
2474}
2475
0a38bafd
PB
2476static void opt_map_meta_data(const char *arg)
2477{
2478 AVMetaDataMap *m;
2479 const char *p;
115329f1 2480
0a38bafd
PB
2481 p = arg;
2482 m = &meta_data_maps[nb_meta_data_maps++];
2483
2484 m->out_file = strtol(arg, (char **)&p, 0);
2485 if (*p)
2486 p++;
2487
2488 m->in_file = strtol(p, (char **)&p, 0);
2489}
2490
b29f97d1 2491static void opt_recording_time(const char *arg)
85f07f22
FB
2492{
2493 recording_time = parse_date(arg, 1);
2494}
2495
8831db5c
MN
2496static void opt_start_time(const char *arg)
2497{
2498 start_time = parse_date(arg, 1);
2499}
2500
4568325a
RS
2501static void opt_rec_timestamp(const char *arg)
2502{
2503 rec_timestamp = parse_date(arg, 0) / 1000000;
2504}
2505
a6a92a9a
WG
2506static void opt_input_ts_offset(const char *arg)
2507{
2508 input_ts_offset = parse_date(arg, 1);
2509}
2510
b29f97d1 2511static void opt_input_file(const char *filename)
85f07f22
FB
2512{
2513 AVFormatContext *ic;
2514 AVFormatParameters params, *ap = &params;
14bea432 2515 int err, i, ret, rfps, rfps_base;
bd1b79a1 2516 int64_t timestamp;
85f07f22 2517
b242baa4
FB
2518 if (!strcmp(filename, "-"))
2519 filename = "pipe:";
2520
115329f1 2521 using_stdin |= !strncmp(filename, "pipe:", 5) ||
d9a916e2
CY
2522 !strcmp( filename, "/dev/stdin" );
2523
85f07f22 2524 /* get default parameters from command line */
4eb72c6b
NS
2525 ic = av_alloc_format_context();
2526
79fdaa4c 2527 memset(ap, 0, sizeof(*ap));
4eb72c6b 2528 ap->prealloced_context = 1;
79fdaa4c
FB
2529 ap->sample_rate = audio_sample_rate;
2530 ap->channels = audio_channels;
c0df9d75
MN
2531 ap->time_base.den = frame_rate;
2532 ap->time_base.num = frame_rate_base;
1ff93ffc
TK
2533 ap->width = frame_width + frame_padleft + frame_padright;
2534 ap->height = frame_height + frame_padtop + frame_padbottom;
63167088 2535 ap->pix_fmt = frame_pix_fmt;
2639c651
RS
2536 ap->channel = video_channel;
2537 ap->standard = video_standard;
5b6d5596
MN
2538 ap->video_codec_id = video_codec_id;
2539 ap->audio_codec_id = audio_codec_id;
2540 if(pgmyuv_compatibility_hack)
2541 ap->video_codec_id= CODEC_ID_PGMYUV;
79fdaa4c 2542
4eb72c6b 2543 for(i=0; i<opt_name_count; i++){
bd31a388 2544 const AVOption *opt;
4eb72c6b
NS
2545 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2546 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2547 av_set_double(ic, opt_names[i], d);
2548 }
79fdaa4c
FB
2549 /* open the input file with generic libav function */
2550 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
85f07f22 2551 if (err < 0) {
79fdaa4c 2552 print_error(filename, err);
85f07f22
FB
2553 exit(1);
2554 }
30bc6613 2555
5894e1bb
VP
2556 ic->loop_input = loop_input;
2557
79fdaa4c
FB
2558 /* If not enough info to get the stream parameters, we decode the
2559 first frames to get it. (used in mpeg case for example) */
2560 ret = av_find_stream_info(ic);
d8019eb5 2561 if (ret < 0 && verbose >= 0) {
85f07f22
FB
2562 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2563 exit(1);
2564 }
2565
bd1b79a1
MN
2566 timestamp = start_time;
2567 /* add the stream start time */
2568 if (ic->start_time != AV_NOPTS_VALUE)
2569 timestamp += ic->start_time;
2570
254abc2e
FB
2571 /* if seeking requested, we execute it */
2572 if (start_time != 0) {
3ba1438d 2573 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
254abc2e 2574 if (ret < 0) {
115329f1 2575 fprintf(stderr, "%s: could not seek to position %0.3f\n",
254abc2e
FB
2576 filename, (double)timestamp / AV_TIME_BASE);
2577 }
2578 /* reset seek info */
2579 start_time = 0;
2580 }
2581
85f07f22
FB
2582 /* update the current parameters so that they match the one of the input stream */
2583 for(i=0;i<ic->nb_streams;i++) {
637b5326 2584 int j;
01f4895c 2585 AVCodecContext *enc = ic->streams[i]->codec;
2450cff2 2586#if defined(HAVE_THREADS)
c62c07d3
MN
2587 if(thread_count>1)
2588 avcodec_thread_init(enc, thread_count);
2589#endif
2590 enc->thread_count= thread_count;
85f07f22
FB
2591 switch(enc->codec_type) {
2592 case CODEC_TYPE_AUDIO:
637b5326 2593 for(j=0; j<opt_name_count; j++){
bd31a388 2594 const AVOption *opt;
23b254fb 2595 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
637b5326
MN
2596 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2597 av_set_double(enc, opt_names[j], d);
2598 }
e0d2714a 2599 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
85f07f22
FB
2600 audio_channels = enc->channels;
2601 audio_sample_rate = enc->sample_rate;
b4aea108 2602 if(audio_disable)
f3356e9c 2603 ic->streams[i]->discard= AVDISCARD_ALL;
85f07f22
FB
2604 break;
2605 case CODEC_TYPE_VIDEO:
637b5326 2606 for(j=0; j<opt_name_count; j++){
bd31a388 2607 const AVOption *opt;
23b254fb 2608 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
637b5326
MN
2609 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2610 av_set_double(enc, opt_names[j], d);
2611 }
85f07f22
FB
2612 frame_height = enc->height;
2613 frame_width = enc->width;
bb270c08
DB
2614 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2615 frame_pix_fmt = enc->pix_fmt;
c0df9d75
MN
2616 rfps = ic->streams[i]->r_frame_rate.num;
2617 rfps_base = ic->streams[i]->r_frame_rate.den;
637b5326 2618 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
f4f3223f
MN
2619 if(me_threshold)
2620 enc->debug |= FF_DEBUG_MV;
d7425f59 2621
115329f1 2622 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
d8019eb5
AD
2623
2624 if (verbose >= 0)
386c88de 2625 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
c0df9d75 2626 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
d8019eb5 2627
15bc38e5 2628 (float)rfps / rfps_base, rfps, rfps_base);
79fdaa4c 2629 }
bf5af568 2630 /* update the current frame rate to match the stream frame rate */
14bea432
MN
2631 frame_rate = rfps;
2632 frame_rate_base = rfps_base;
bdfcbbed
MK
2633
2634 enc->rate_emu = rate_emu;
b4aea108 2635 if(video_disable)
f3356e9c
MN
2636 ic->streams[i]->discard= AVDISCARD_ALL;
2637 else if(video_discard)
2638 ic->streams[i]->discard= video_discard;
85f07f22 2639 break;
254abc2e
FB
2640 case CODEC_TYPE_DATA:
2641 break;
cf7fc795
FB
2642 case CODEC_TYPE_SUBTITLE:
2643 break;
ae38261e
MB
2644 case CODEC_TYPE_UNKNOWN:
2645 break;
51bd4565 2646 default:
c04643a2 2647 av_abort();
85f07f22
FB
2648 }
2649 }
115329f1 2650
85f07f22 2651 input_files[nb_input_files] = ic;
bd1b79a1 2652 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
85f07f22 2653 /* dump the file content */
d8019eb5
AD
2654 if (verbose >= 0)
2655 dump_format(ic, nb_input_files, filename, 0);
2656
85f07f22 2657 nb_input_files++;
79fdaa4c
FB
2658 file_iformat = NULL;
2659 file_oformat = NULL;
bdfcbbed 2660
2639c651 2661 video_channel = 0;
115329f1 2662
bdfcbbed 2663 rate_emu = 0;
85f07f22
FB
2664}
2665
b29f97d1 2666static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
919f448d
FB
2667{
2668 int has_video, has_audio, i, j;
2669 AVFormatContext *ic;
2670
2671 has_video = 0;
2672 has_audio = 0;
2673 for(j=0;j<nb_input_files;j++) {
2674 ic = input_files[j];
2675 for(i=0;i<ic->nb_streams;i++) {
01f4895c 2676 AVCodecContext *enc = ic->streams[i]->codec;
919f448d
FB
2677 switch(enc->codec_type) {
2678 case CODEC_TYPE_AUDIO:
2679 has_audio = 1;
2680 break;
2681 case CODEC_TYPE_VIDEO:
2682 has_video = 1;
2683 break;
6fb316d5 2684 case CODEC_TYPE_DATA:
ae38261e 2685 case CODEC_TYPE_UNKNOWN:
cf7fc795 2686 case CODEC_TYPE_SUBTITLE:
6fb316d5 2687 break;
51bd4565 2688 default:
c04643a2 2689 av_abort();
919f448d
FB
2690 }
2691 }
2692 }
2693 *has_video_ptr = has_video;
2694 *has_audio_ptr = has_audio;
2695}
2696
cf7fc795 2697static void new_video_stream(AVFormatContext *oc)
85f07f22
FB
2698{
2699 AVStream *st;
cf7fc795
FB
2700 AVCodecContext *video_enc;
2701 int codec_id;
115329f1 2702
cf7fc795
FB
2703 st = av_new_stream(oc, oc->nb_streams);
2704 if (!st) {
2705 fprintf(stderr, "Could not alloc stream\n");
2706 exit(1);
2707 }
748c2fca
MN
2708 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2709 video_bitstream_filters= NULL;
2710
cf7fc795
FB
2711#if defined(HAVE_THREADS)
2712 if(thread_count>1)
01f4895c 2713 avcodec_thread_init(st->codec, thread_count);
cf7fc795 2714#endif
115329f1 2715
01f4895c 2716 video_enc = st->codec;
115329f1 2717
cf7fc795
FB
2718 if(video_codec_tag)
2719 video_enc->codec_tag= video_codec_tag;
115329f1 2720
90ad92b3 2721 if( (video_global_header&1)
637b5326 2722 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
cf7fc795 2723 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
23b254fb 2724 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
637b5326
MN
2725 }
2726 if(video_global_header&2){
90ad92b3 2727 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
23b254fb 2728 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
637b5326 2729 }
90ad92b3 2730
cf7fc795
FB
2731 if (video_stream_copy) {
2732 st->stream_copy = 1;
2733 video_enc->codec_type = CODEC_TYPE_VIDEO;
2734 } else {
2735 char *p;
2736 int i;
2737 AVCodec *codec;
115329f1 2738
cf7fc795
FB
2739 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2740 if (video_codec_id != CODEC_ID_NONE)
2741 codec_id = video_codec_id;
115329f1 2742
cf7fc795
FB
2743 video_enc->codec_id = codec_id;
2744 codec = avcodec_find_encoder(codec_id);
115329f1 2745
8bbf6db9 2746 for(i=0; i<opt_name_count; i++){
bd31a388 2747 const AVOption *opt;
23b254fb 2748 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
8bbf6db9
MN
2749 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2750 av_set_double(video_enc, opt_names[i], d);
2751 }
115329f1 2752
115329f1
DB
2753 video_enc->time_base.den = frame_rate;
2754 video_enc->time_base.num = frame_rate_base;
cf7fc795
FB
2755 if(codec && codec->supported_framerates){
2756 const AVRational *p= codec->supported_framerates;
2757 AVRational req= (AVRational){frame_rate, frame_rate_base};
2758 const AVRational *best=NULL;
2759 AVRational best_error= (AVRational){INT_MAX, 1};
2760 for(; p->den!=0; p++){
2761 AVRational error= av_sub_q(req, *p);
2762 if(error.num <0) error.num *= -1;
2763 if(av_cmp_q(error, best_error) < 0){
2764 best_error= error;
2765 best= p;
2766 }
2767 }
2768 video_enc->time_base.den= best->num;
2769 video_enc->time_base.num= best->den;
2770 }
115329f1 2771
cf7fc795
FB
2772 video_enc->width = frame_width + frame_padright + frame_padleft;
2773 video_enc->height = frame_height + frame_padtop + frame_padbottom;
e7268d51 2774 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
cf7fc795
FB
2775 video_enc->pix_fmt = frame_pix_fmt;
2776
2777 if(codec && codec->pix_fmts){
2778 const enum PixelFormat *p= codec->pix_fmts;
2779 for(; *p!=-1; p++){
2780 if(*p == video_enc->pix_fmt)
2781 break;
2782 }
2783 if(*p == -1)
2784 video_enc->pix_fmt = codec->pix_fmts[0];
2785 }
2786
babe0e8c 2787 if (intra_only)
cf7fc795
FB
2788 video_enc->gop_size = 0;
2789 if (video_qscale || same_quality) {
2790 video_enc->flags |= CODEC_FLAG_QSCALE;
115329f1 2791 video_enc->global_quality=
cf7fc795
FB
2792 st->quality = FF_QP2LAMBDA * video_qscale;
2793 }
2794
2795 if(intra_matrix)
2796 video_enc->intra_matrix = intra_matrix;
2797 if(inter_matrix)
2798 video_enc->inter_matrix = inter_matrix;
2799
cf7fc795 2800 video_enc->max_qdiff = video_qdiff;
cf7fc795 2801 video_enc->rc_eq = video_rc_eq;
cf7fc795
FB
2802 video_enc->thread_count = thread_count;
2803 p= video_rc_override_string;
2804 for(i=0; p; i++){
2805 int start, end, q;
2806 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2807 if(e!=3){
2808 fprintf(stderr, "error parsing rc_override\n");
2809 exit(1);
2810 }
115329f1
DB
2811 video_enc->rc_override=
2812 av_realloc(video_enc->rc_override,
cf7fc795
FB
2813 sizeof(RcOverride)*(i+1));
2814 video_enc->rc_override[i].start_frame= start;
2815 video_enc->rc_override[i].end_frame = end;
2816 if(q>0){
2817 video_enc->rc_override[i].qscale= q;
2818 video_enc->rc_override[i].quality_factor= 1.0;
2819 }
2820 else{
2821 video_enc->rc_override[i].qscale= 0;
2822 video_enc->rc_override[i].quality_factor= -q/100.0;
2823 }
2824 p= strchr(p, '/');
2825 if(p) p++;
2826 }
2827 video_enc->rc_override_count=i;
079e8cb9
BC
2828 if (!video_enc->rc_initial_buffer_occupancy)
2829 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
cf7fc795 2830 video_enc->me_threshold= me_threshold;
cf7fc795
FB
2831 video_enc->intra_dc_precision= intra_dc_precision - 8;
2832 video_enc->strict_std_compliance = strict;
cf7fc795 2833
cf7fc795
FB
2834 if (do_psnr)
2835 video_enc->flags|= CODEC_FLAG_PSNR;
115329f1 2836
cf7fc795
FB
2837 video_enc->me_method = me_method;
2838
2839 /* two pass mode */
2840 if (do_pass) {
2841 if (do_pass == 1) {
2842 video_enc->flags |= CODEC_FLAG_PASS1;
2843 } else {
2844 video_enc->flags |= CODEC_FLAG_PASS2;
2845 }
2846 }
2847 }
2848
2849 /* reset some key parameters */
2850 video_disable = 0;
2851 video_codec_id = CODEC_ID_NONE;
2852 video_stream_copy = 0;
2853}
2854
2855static void new_audio_stream(AVFormatContext *oc)
2856{
2857 AVStream *st;
2858 AVCodecContext *audio_enc;
8bbf6db9 2859 int codec_id, i;
115329f1 2860
cf7fc795
FB
2861 st = av_new_stream(oc, oc->nb_streams);
2862 if (!st) {
2863 fprintf(stderr, "Could not alloc stream\n");
2864 exit(1);
2865 }
748c2fca
MN
2866
2867 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2868 audio_bitstream_filters= NULL;
2869
cf7fc795
FB
2870#if defined(HAVE_THREADS)
2871 if(thread_count>1)
01f4895c 2872 avcodec_thread_init(st->codec, thread_count);
cf7fc795 2873#endif
115329f1 2874
01f4895c 2875 audio_enc = st->codec;
cf7fc795 2876 audio_enc->codec_type = CODEC_TYPE_AUDIO;
f889d3f9 2877 audio_enc->strict_std_compliance = strict;
115329f1 2878
cf7fc795
FB
2879 if(audio_codec_tag)
2880 audio_enc->codec_tag= audio_codec_tag;
115329f1 2881
637b5326 2882 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
cf7fc795 2883 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
23b254fb 2884 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
637b5326 2885 }
cf7fc795
FB
2886 if (audio_stream_copy) {
2887 st->stream_copy = 1;
2888 audio_enc->channels = audio_channels;
2889 } else {
2890 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
115329f1 2891
8bbf6db9 2892 for(i=0; i<opt_name_count; i++){
bd31a388 2893 const AVOption *opt;
23b254fb 2894 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
8bbf6db9
MN
2895 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2896 av_set_double(audio_enc, opt_names[i], d);
2897 }
115329f1 2898
cf7fc795
FB
2899 if (audio_codec_id != CODEC_ID_NONE)
2900 codec_id = audio_codec_id;
2901 audio_enc->codec_id = codec_id;
115329f1 2902
c57c770d
JR
2903 if (audio_qscale > QSCALE_NONE) {
2904 audio_enc->flags |= CODEC_FLAG_QSCALE;
2905 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2906 }
cf7fc795 2907 audio_enc->thread_count = thread_count;
e3e3be53 2908 audio_enc->channels = audio_channels;
cf7fc795
FB
2909 }
2910 audio_enc->sample_rate = audio_sample_rate;
78e03516 2911 audio_enc->time_base= (AVRational){1, audio_sample_rate};
cf7fc795
FB
2912 if (audio_language) {
2913 pstrcpy(st->language, sizeof(st->language), audio_language);
2914 av_free(audio_language);
2915 audio_language = NULL;
2916 }
2917
2918 /* reset some key parameters */
2919 audio_disable = 0;
2920 audio_codec_id = CODEC_ID_NONE;
2921 audio_stream_copy = 0;
2922}
2923
2924static void opt_new_subtitle_stream(void)
2925{
2926 AVFormatContext *oc;
2927 AVStream *st;
2928 AVCodecContext *subtitle_enc;
8bbf6db9 2929 int i;
115329f1 2930
cf7fc795
FB
2931 if (nb_output_files <= 0) {
2932 fprintf(stderr, "At least one output file must be specified\n");
2933 exit(1);
2934 }
2935 oc = output_files[nb_output_files - 1];
2936
2937 st = av_new_stream(oc, oc->nb_streams);
2938 if (!st) {
2939 fprintf(stderr, "Could not alloc stream\n");
2940 exit(1);
2941 }
2942
01f4895c 2943 subtitle_enc = st->codec;
cf7fc795
FB
2944 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2945 if (subtitle_stream_copy) {
2946 st->stream_copy = 1;
2947 } else {
8bbf6db9 2948 for(i=0; i<opt_name_count; i++){
bd31a388 2949 const AVOption *opt;
23b254fb 2950 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
8bbf6db9
MN
2951 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2952 av_set_double(subtitle_enc, opt_names[i], d);
2953 }
cf7fc795
FB
2954 subtitle_enc->codec_id = subtitle_codec_id;
2955 }
2956
2957 if (subtitle_language) {
2958 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2959 av_free(subtitle_language);
2960 subtitle_language = NULL;
2961 }
2962
2963 subtitle_codec_id = CODEC_ID_NONE;
2964 subtitle_stream_copy = 0;
2965}
2966
2967static void opt_new_audio_stream(void)
2968{
2969 AVFormatContext *oc;
2970 if (nb_output_files <= 0) {
2971 fprintf(stderr, "At least one output file must be specified\n");
2972 exit(1);
2973 }
2974 oc = output_files[nb_output_files - 1];
2975 new_audio_stream(oc);
2976}
2977
2978static void opt_new_video_stream(void)
2979{
2980 AVFormatContext *oc;
2981 if (nb_output_files <= 0) {
2982 fprintf(stderr, "At least one output file must be specified\n");
2983 exit(1);
2984 }
2985 oc = output_files[nb_output_files - 1];
2986 new_video_stream(oc);
2987}
2988
2989static void opt_output_file(const char *filename)
2990{
2991 AVFormatContext *oc;
8e16b25c 2992 int use_video, use_audio, input_has_video, input_has_audio, i;
817b23ff 2993 AVFormatParameters params, *ap = &params;
85f07f22
FB
2994
2995 if (!strcmp(filename, "-"))
2996 filename = "pipe:";
2997
bc874dae 2998 oc = av_alloc_format_context();
85f07f22 2999
79fdaa4c
FB
3000 if (!file_oformat) {
3001 file_oformat = guess_format(NULL, filename, NULL);
3002 if (!file_oformat) {
3003 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3004 filename);
3005 exit(1);
3006 }
85f07f22 3007 }
115329f1 3008
79fdaa4c 3009 oc->oformat = file_oformat;
cf7fc795 3010 pstrcpy(oc->filename, sizeof(oc->filename), filename);
85f07f22 3011
115329f1 3012 if (!strcmp(file_oformat->name, "ffm") &&
85f07f22
FB
3013 strstart(filename, "http:", NULL)) {
3014 /* special case for files sent to ffserver: we get the stream
3015 parameters from ffserver */
3016 if (read_ffserver_streams(oc, filename) < 0) {
3017 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3018 exit(1);
3019 }
3020 } else {
f2d9a9f5
LA
3021 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3022 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
919f448d 3023
e30a2846
FB
3024 /* disable if no corresponding type found and at least one
3025 input file */
3026 if (nb_input_files > 0) {
3027 check_audio_video_inputs(&input_has_video, &input_has_audio);
3028 if (!input_has_video)
3029 use_video = 0;
3030 if (!input_has_audio)
3031 use_audio = 0;
3032 }
919f448d
FB
3033
3034 /* manual disable */
85f07f22
FB
3035 if (audio_disable) {
3036 use_audio = 0;
3037 }
3038 if (video_disable) {
3039 use_video = 0;
3040 }
115329f1 3041
85f07f22 3042 if (use_video) {
cf7fc795 3043 new_video_stream(oc);
85f07f22 3044 }
115329f1 3045
85f07f22 3046 if (use_audio) {
cf7fc795 3047 new_audio_stream(oc);
85f07f22
FB
3048 }
3049
4568325a 3050 oc->timestamp = rec_timestamp;
115329f1 3051
bb270c08 3052 if (str_title)
79fdaa4c 3053 pstrcpy(oc->title, sizeof(oc->title), str_title);
85f07f22 3054 if (str_author)
79fdaa4c 3055 pstrcpy(oc->author, sizeof(oc->author), str_author);
85f07f22 3056 if (str_copyright)
79fdaa4c 3057 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
85f07f22 3058 if (str_comment)
79fdaa4c 3059 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
63d5075c
PI
3060 if (str_album)
3061 pstrcpy(oc->album, sizeof(oc->album), str_album);
85f07f22
FB
3062 }
3063
1629626f 3064 output_files[nb_output_files++] = oc;
85f07f22 3065
919f448d 3066 /* check filename in case of an image number is expected */
79fdaa4c 3067 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5c07cf53 3068 if (!av_filename_number_test(oc->filename)) {
79fdaa4c 3069 print_error(oc->filename, AVERROR_NUMEXPECTED);
919f448d 3070 exit(1);
79fdaa4c 3071 }
919f448d
FB
3072 }
3073
79fdaa4c 3074 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
85f07f22 3075 /* test if it already exists to avoid loosing precious files */
115329f1 3076 if (!file_overwrite &&
85f07f22
FB
3077 (strchr(filename, ':') == NULL ||
3078 strstart(filename, "file:", NULL))) {
3079 if (url_exist(filename)) {
3080 int c;
115329f1 3081
d9a916e2
CY
3082 if ( !using_stdin ) {
3083 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3084 fflush(stderr);
3085 c = getchar();
3086 if (toupper(c) != 'Y') {
3087 fprintf(stderr, "Not overwriting - exiting\n");
3088 exit(1);
3089 }
bb270c08
DB
3090 }
3091 else {
d9a916e2 3092 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
85f07f22 3093 exit(1);
bb270c08 3094 }
85f07f22
FB
3095 }
3096 }
115329f1 3097
85f07f22
FB
3098 /* open the file */
3099 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3100 fprintf(stderr, "Could not open '%s'\n", filename);
3101 exit(1);
3102 }
3103 }
3104
817b23ff 3105 memset(ap, 0, sizeof(*ap));
817b23ff
FB
3106 if (av_set_parameters(oc, ap) < 0) {
3107 fprintf(stderr, "%s: Invalid encoding parameters\n",
3108 oc->filename);
3109 exit(1);
3110 }
3111
17c88cb0
MN
3112 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3113 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
8108551a 3114 oc->loop_output = loop_output;
2db3c638 3115
8e16b25c 3116 for(i=0; i<opt_name_count; i++){
bd31a388 3117 const AVOption *opt;
8e16b25c
PI
3118 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3119 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3120 av_set_double(oc, opt_names[i], d);
3121 }
3122
85f07f22 3123 /* reset some options */
79fdaa4c
FB
3124 file_oformat = NULL;
3125 file_iformat = NULL;
85f07f22
FB
3126}
3127
5abdb4b1 3128/* same option as mencoder */
b29f97d1 3129static void opt_pass(const char *pass_str)
5abdb4b1
FB
3130{
3131 int pass;
3132 pass = atoi(pass_str);
3133 if (pass != 1 && pass != 2) {
3134 fprintf(stderr, "pass number can be only 1 or 2\n");
3135 exit(1);
3136 }
3137 do_pass = pass;
3138}
a38469e1 3139
2f30a81d 3140#if defined(__MINGW32__) || defined(CONFIG_OS2)
0c1a9eda 3141static int64_t getutime(void)
5727b222 3142{
f3ec2d46 3143 return av_gettime();
5727b222 3144}
bdc4796f 3145#else
0c1a9eda 3146static int64_t getutime(void)
bdc4796f 3147{
f3ec2d46
SG
3148 struct rusage rusage;
3149
3150 getrusage(RUSAGE_SELF, &rusage);
3151 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
bdc4796f
FB
3152}
3153#endif
5727b222 3154
e8a42081 3155#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
79fdaa4c 3156extern int ffm_nopts;
e8a42081 3157#endif
79fdaa4c 3158
b29f97d1 3159static void show_formats(void)
85f07f22 3160{
79fdaa4c
FB
3161 AVInputFormat *ifmt;
3162 AVOutputFormat *ofmt;
85f07f22 3163 URLProtocol *up;
3738fe1a
MN
3164 AVCodec *p, *p2;
3165 const char **pp, *last_name;
3166
3167 printf("File formats:\n");
3168 last_name= "000";
3169 for(;;){
3170 int decode=0;
3171 int encode=0;
3172 const char *name=NULL;
92a80570 3173 const char *long_name=NULL;
3738fe1a
MN
3174
3175 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3176 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3177 strcmp(ofmt->name, last_name)>0){
3178 name= ofmt->name;
92a80570 3179 long_name= ofmt->long_name;
3738fe1a
MN
3180 encode=1;
3181 }
3182 }
3183 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3184 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3185 strcmp(ifmt->name, last_name)>0){
3186 name= ifmt->name;
92a80570 3187 long_name= ifmt->long_name;
3738fe1a
MN
3188 encode=0;
3189 }
3190 if(name && strcmp(ifmt->name, name)==0)
3191 decode=1;
3192 }
3193 if(name==NULL)
3194 break;
3195 last_name= name;
115329f1 3196
3738fe1a 3197 printf(
115329f1
DB
3198 " %s%s %-15s %s\n",
3199 decode ? "D":" ",
3200 encode ? "E":" ",
92a80570
MN
3201 name,
3202 long_name ? long_name:" ");
817b23ff
FB
3203 }
3204 printf("\n");
3205
85f07f22 3206 printf("Codecs:\n");
3738fe1a
MN
3207 last_name= "000";
3208 for(;;){
3209 int decode=0;
3210 int encode=0;
3211 int cap=0;
cf7fc795 3212 const char *type_str;
3738fe1a
MN
3213
3214 p2=NULL;
3215 for(p = first_avcodec; p != NULL; p = p->next) {
3216 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3217 strcmp(p->name, last_name)>0){
3218 p2= p;
3219 decode= encode= cap=0;
3220 }
3221 if(p2 && strcmp(p->name, p2->name)==0){
3222 if(p->decode) decode=1;
3223 if(p->encode) encode=1;
3224 cap |= p->capabilities;
3225 }
3226 }
3227 if(p2==NULL)
3228 break;
3229 last_name= p2->name;
115329f1 3230
cf7fc795
FB
3231 switch(p2->type) {
3232 case CODEC_TYPE_VIDEO:
3233 type_str = "V";
3234 break;
3235 case CODEC_TYPE_AUDIO:
3236 type_str = "A";
3237 break;
3238 case CODEC_TYPE_SUBTITLE:
3239 type_str = "S";
3240 break;
3241 default:
3242 type_str = "?";
3243 break;
3244 }
3738fe1a 3245 printf(
115329f1
DB
3246 " %s%s%s%s%s%s %s",
3247 decode ? "D": (/*p2->decoder ? "d":*/" "),
3248 encode ? "E":" ",
cf7fc795 3249 type_str,
3738fe1a
MN
3250 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3251 cap & CODEC_CAP_DR1 ? "D":" ",
3252 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3253 p2->name);
3254 /* if(p2->decoder && decode==0)
3255 printf(" use %s for decoding", p2->decoder->name);*/
3256 printf("\n");
85f07f22
FB
3257 }
3258 printf("\n");
3259
3738fe1a 3260 printf("Supported file protocols:\n");
85f07f22
FB
3261 for(up = first_protocol; up != NULL; up = up->next)
3262 printf(" %s:", up->name);
3263 printf("\n");
115329f1 3264
3738fe1a
MN
3265 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3266 printf("Motion estimation methods:\n");
85f07f22
FB
3267 pp = motion_str;
3268 while (*pp) {
3269 printf(" %s", *pp);
115329f1 3270 if ((pp - motion_str + 1) == ME_ZERO)
85f07f22 3271 printf("(fastest)");
115329f1 3272 else if ((pp - motion_str + 1) == ME_FULL)
85f07f22 3273 printf("(slowest)");
115329f1 3274 else if ((pp - motion_str + 1) == ME_EPZS)
85f07f22
FB
3275 printf("(default)");
3276 pp++;
3277 }
3738fe1a
MN
3278 printf("\n\n");
3279 printf(
3280"Note, the names of encoders and decoders dont always match, so there are\n"
3281"several cases where the above table shows encoder only or decoder only entries\n"
3282"even though both encoding and decoding are supported for example, the h263\n"
3283"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3284"worse\n");
85f07f22
FB
3285 exit(1);
3286}
3287
ceaf1909 3288static void parse_matrix_coeffs(uint16_t *dest, const char *str)
84f608f4
VM
3289{
3290 int i;
3291 const char *p = str;
3292 for(i = 0;; i++) {
3293 dest[i] = atoi(p);
3294 if(i == 63)
3295 break;
3296 p = strchr(p, ',');
3297 if(!p) {
3298 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3299 exit(1);
3300 }
3301 p++;
3302 }
3303}
3304
ceaf1909 3305static void opt_inter_matrix(const char *arg)
84f608f4
VM
3306{
3307 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3308 parse_matrix_coeffs(inter_matrix, arg);
3309}
3310
ceaf1909 3311static void opt_intra_matrix(const char *arg)
84f608f4
VM
3312{
3313 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3314 parse_matrix_coeffs(intra_matrix, arg);
3315}
3316
e0595741
VM
3317static void opt_target(const char *arg)
3318{
3319 int norm = -1;
88730be6 3320 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
e0595741
VM
3321
3322 if(!strncmp(arg, "pal-", 4)) {
3323 norm = 0;
3324 arg += 4;
3325 } else if(!strncmp(arg, "ntsc-", 5)) {
3326 norm = 1;
3327 arg += 5;
ed2d7a34
PI
3328 } else if(!strncmp(arg, "film-", 5)) {
3329 norm = 2;
3330 arg += 5;
e0595741
VM
3331 } else {
3332 int fr;
3333 /* Calculate FR via float to avoid int overflow */
3334 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3335 if(fr == 25000) {
3336 norm = 0;
3337 } else if((fr == 29970) || (fr == 23976)) {
3338 norm = 1;
3339 } else {
3340 /* Try to determine PAL/NTSC by peeking in the input files */
3341 if(nb_input_files) {
3342 int i, j;
3343 for(j = 0; j < nb_input_files; j++) {
3344 for(i = 0; i < input_files[j]->nb_streams; i++) {
01f4895c 3345 AVCodecContext *c = input_files[j]->streams[i]->codec;
e0595741
VM
3346 if(c->codec_type != CODEC_TYPE_VIDEO)
3347 continue;
c0df9d75 3348 fr = c->time_base.den * 1000 / c->time_base.num;
e0595741
VM
3349 if(fr == 25000) {
3350 norm = 0;
3351 break;
3352 } else if((fr == 29970) || (fr == 23976)) {
3353 norm = 1;
3354 break;
3355 }
3356 }
3357 if(norm >= 0)
3358 break;
3359 }
3360 }
3361 }