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