?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove some useless assignments (the UDPContext is allocated with av_mallocz())
[ffmpeg-lucabe.git] / ffmpeg.c
blob020ac2e59c354913b0ba8dc3e5e73c1897e908ca
1 /*
2 * FFmpeg main
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "config.h"
23 #include <ctype.h>
24 #include <string.h>
25 #include <math.h>
26 #include <stdlib.h>
27 #include <errno.h>
28 #include <signal.h>
29 #include <limits.h>
30 #include "avformat.h"
31 #include "swscale.h"
32 #include "framehook.h"
33 #include "opt.h"
34 #include "fifo.h"
35 #include "avstring.h"
36
37 #if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
38 #include <windows.h>
39 #endif
40
41 #if defined(HAVE_TERMIOS_H)
42 #include <unistd.h>
43 #include <fcntl.h>
44 #include <sys/ioctl.h>
45 #include <sys/time.h>
46 #include <termios.h>
47 #include <sys/resource.h>
48 #elif defined(HAVE_CONIO_H)
49 #include <conio.h>
50 #endif
51 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
52 #include <time.h>
53
54 #include "version.h"
55 #include "cmdutils.h"
56
57 #undef NDEBUG
58 #include <assert.h>
59
60 #if !defined(INFINITY) && defined(HUGE_VAL)
61 #define INFINITY HUGE_VAL
62 #endif
63
64 #undef exit
65
66 static const char program_name[] = "FFmpeg";
67 static const int program_birth_year = 2000;
68
69 /* select an input stream for an output stream */
70 typedef struct AVStreamMap {
71 int file_index;
72 int stream_index;
73 int sync_file_index;
74 int sync_stream_index;
75 } AVStreamMap;
76
77 /** select an input file for an output file */
78 typedef struct AVMetaDataMap {
79 int out_file;
80 int in_file;
81 } AVMetaDataMap;
82
83 extern const OptionDef options[];
84
85 static void show_help(void);
86 static void opt_show_license(void);
87 static int opt_default(const char *opt, const char *arg);
88
89 #define MAX_FILES 20
90
91 static AVFormatContext *input_files[MAX_FILES];
92 static int64_t input_files_ts_offset[MAX_FILES];
93 static int nb_input_files = 0;
94
95 static AVFormatContext *output_files[MAX_FILES];
96 static int nb_output_files = 0;
97
98 static AVStreamMap stream_maps[MAX_FILES];
99 static int nb_stream_maps;
100
101 static AVMetaDataMap meta_data_maps[MAX_FILES];
102 static int nb_meta_data_maps;
103
104 static AVInputFormat *file_iformat;
105 static AVOutputFormat *file_oformat;
106 static int frame_width = 0;
107 static int frame_height = 0;
108 static float frame_aspect_ratio = 0;
109 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
110 static int frame_padtop = 0;
111 static int frame_padbottom = 0;
112 static int frame_padleft = 0;
113 static int frame_padright = 0;
114 static int padcolor[3] = {16,128,128}; /* default to black */
115 static int frame_topBand = 0;
116 static int frame_bottomBand = 0;
117 static int frame_leftBand = 0;
118 static int frame_rightBand = 0;
119 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
120 static AVRational frame_rate = (AVRational) {25,1};
121 static float video_qscale = 0;
122 static int video_qdiff = 3;
123 static uint16_t *intra_matrix = NULL;
124 static uint16_t *inter_matrix = NULL;
125 #if 0 //experimental, (can be removed)
126 static float video_rc_qsquish=1.0;
127 static float video_rc_qmod_amp=0;
128 static int video_rc_qmod_freq=0;
129 #endif
130 static char *video_rc_override_string=NULL;
131 static char *video_rc_eq="tex^qComp";
132 static int video_disable = 0;
133 static int video_discard = 0;
134 static char *video_codec_name = NULL;
135 static int video_codec_tag = 0;
136 static int same_quality = 0;
137 static int do_deinterlace = 0;
138 static int strict = 0;
139 static int top_field_first = -1;
140 static int me_threshold = 0;
141 static int intra_dc_precision = 8;
142 static int loop_input = 0;
143 static int loop_output = AVFMT_NOOUTPUTLOOP;
144 static int qp_hist = 0;
145
146 static int intra_only = 0;
147 static int audio_sample_rate = 44100;
148 #define QSCALE_NONE -99999
149 static float audio_qscale = QSCALE_NONE;
150 static int audio_disable = 0;
151 static int audio_channels = 1;
152 static char *audio_codec_name = NULL;
153 static int audio_codec_tag = 0;
154 static char *audio_language = NULL;
155
156 static int subtitle_disable = 0;
157 static char *subtitle_codec_name = NULL;
158 static char *subtitle_language = NULL;
159
160 static float mux_preload= 0.5;
161 static float mux_max_delay= 0.7;
162
163 static int64_t recording_time = 0;
164 static int64_t start_time = 0;
165 static int64_t rec_timestamp = 0;
166 static int64_t input_ts_offset = 0;
167 static int file_overwrite = 0;
168 static char *str_title = NULL;
169 static char *str_author = NULL;
170 static char *str_copyright = NULL;
171 static char *str_comment = NULL;
172 static char *str_album = NULL;
173 static int do_benchmark = 0;
174 static int do_hex_dump = 0;
175 static int do_pkt_dump = 0;
176 static int do_psnr = 0;
177 static int do_pass = 0;
178 static char *pass_logfilename = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
181 static int subtitle_stream_copy = 0;
182 static int video_sync_method= 1;
183 static int audio_sync_method= 0;
184 static float audio_drift_threshold= 0.1;
185 static int copy_ts= 0;
186 static int opt_shortest = 0; //
187 static int video_global_header = 0;
188 static char *vstats_filename;
189 static FILE *vstats_file;
190 static int opt_programid = 0;
191
192 static int rate_emu = 0;
193
194 static int video_channel = 0;
195 static char *video_standard;
196
197 static int audio_volume = 256;
198
199 static int using_stdin = 0;
200 static int using_vhook = 0;
201 static int verbose = 1;
202 static int thread_count= 1;
203 static int q_pressed = 0;
204 static int64_t video_size = 0;
205 static int64_t audio_size = 0;
206 static int64_t extra_size = 0;
207 static int nb_frames_dup = 0;
208 static int nb_frames_drop = 0;
209 static int input_sync;
210 static uint64_t limit_filesize = 0; //
211
212 static int pgmyuv_compatibility_hack=0;
213 static float dts_delta_threshold = 10;
214
215 static int sws_flags = SWS_BICUBIC;
216
217 static const char **opt_names;
218 static int opt_name_count;
219 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
220 static AVFormatContext *avformat_opts;
221 static struct SwsContext *sws_opts;
222 static int64_t timer_start;
223
224 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
225 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
226 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
227
228 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
229
230 struct AVInputStream;
231
232 typedef struct AVOutputStream {
233 int file_index; /* file index */
234 int index; /* stream index in the output file */
235 int source_index; /* AVInputStream index */
236 AVStream *st; /* stream in the output file */
237 int encoding_needed; /* true if encoding needed for this stream */
238 int frame_number;
239 /* input pts and corresponding output pts
240 for A/V sync */
241 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
242 struct AVInputStream *sync_ist; /* input stream to sync against */
243 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
244 /* video only */
245 int video_resample;
246 AVFrame pict_tmp; /* temporary image for resampling */
247 struct SwsContext *img_resample_ctx; /* for image resampling */
248 int resample_height;
249
250 int video_crop;
251 int topBand; /* cropping area sizes */
252 int leftBand;
253
254 int video_pad;
255 int padtop; /* padding area sizes */
256 int padbottom;
257 int padleft;
258 int padright;
259
260 /* audio only */
261 int audio_resample;
262 ReSampleContext *resample; /* for audio resampling */
263 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
264 FILE *logfile;
265 } AVOutputStream;
266
267 typedef struct AVInputStream {
268 int file_index;
269 int index;
270 AVStream *st;
271 int discard; /* true if stream data should be discarded */
272 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
273 int64_t sample_index; /* current sample */
274
275 int64_t start; /* time when read started */
276 unsigned long frame; /* current frame */
277 int64_t next_pts; /* synthetic pts for cases where pkt.pts
278 is not defined */
279 int64_t pts; /* current pts */
280 int is_start; /* is 1 at the start and after a discontinuity */
281 } AVInputStream;
282
283 typedef struct AVInputFile {
284 int eof_reached; /* true if eof reached */
285 int ist_index; /* index of first stream in ist_table */
286 int buffer_size; /* current total buffer size */
287 int nb_streams; /* nb streams we are aware of */
288 } AVInputFile;
289
290 #ifdef HAVE_TERMIOS_H
291
292 /* init terminal so that we can grab keys */
293 static struct termios oldtty;
294 #endif
295
296 static void term_exit(void)
297 {
298 #ifdef HAVE_TERMIOS_H
299 tcsetattr (0, TCSANOW, &oldtty);
300 #endif
301 }
302
303 static volatile sig_atomic_t received_sigterm = 0;
304
305 static void
306 sigterm_handler(int sig)
307 {
308 received_sigterm = sig;
309 term_exit();
310 }
311
312 static void term_init(void)
313 {
314 #ifdef HAVE_TERMIOS_H
315 struct termios tty;
316
317 tcgetattr (0, &tty);
318 oldtty = tty;
319
320 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
321 |INLCR|IGNCR|ICRNL|IXON);
322 tty.c_oflag |= OPOST;
323 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
324 tty.c_cflag &= ~(CSIZE|PARENB);
325 tty.c_cflag |= CS8;
326 tty.c_cc[VMIN] = 1;
327 tty.c_cc[VTIME] = 0;
328
329 tcsetattr (0, TCSANOW, &tty);
330 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
331 #endif
332
333 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
334 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
335 /*
336 register a function to be called at normal program termination
337 */
338 atexit(term_exit);
339 #ifdef CONFIG_BEOS_NETSERVER
340 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
341 #endif
342 }
343
344 /* read a key without blocking */
345 static int read_key(void)
346 {
347 #if defined(HAVE_TERMIOS_H)
348 int n = 1;
349 unsigned char ch;
350 #ifndef CONFIG_BEOS_NETSERVER
351 struct timeval tv;
352 fd_set rfds;
353
354 FD_ZERO(&rfds);
355 FD_SET(0, &rfds);
356 tv.tv_sec = 0;
357 tv.tv_usec = 0;
358 n = select(1, &rfds, NULL, NULL, &tv);
359 #endif
360 if (n > 0) {
361 n = read(0, &ch, 1);
362 if (n == 1)
363 return ch;
364
365 return n;
366 }
367 #elif defined(HAVE_CONIO_H)
368 if(kbhit())
369 return(getch());
370 #endif
371 return -1;
372 }
373
374 static int decode_interrupt_cb(void)
375 {
376 return q_pressed || (q_pressed = read_key() == 'q');
377 }
378
379 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
380 {
381 int i, err;
382 AVFormatContext *ic;
383
384 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
385 if (err < 0)
386 return err;
387 /* copy stream format */
388 s->nb_streams = ic->nb_streams;
389 for(i=0;i<ic->nb_streams;i++) {
390 AVStream *st;
391
392 // FIXME: a more elegant solution is needed
393 st = av_mallocz(sizeof(AVStream));
394 memcpy(st, ic->streams[i], sizeof(AVStream));
395 st->codec = avcodec_alloc_context();
396 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
397 s->streams[i] = st;
398 }
399
400 av_close_input_file(ic);
401 return 0;
402 }
403
404 static double
405 get_sync_ipts(const AVOutputStream *ost)
406 {
407 const AVInputStream *ist = ost->sync_ist;
408 return (double)(ist->pts - start_time)/AV_TIME_BASE;
409 }
410
411 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
412 int ret;
413
414 while(bsfc){
415 AVPacket new_pkt= *pkt;
416 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
417 &new_pkt.data, &new_pkt.size,
418 pkt->data, pkt->size,
419 pkt->flags & PKT_FLAG_KEY);
420 if(a){
421 av_free_packet(pkt);
422 new_pkt.destruct= av_destruct_packet;
423 }
424 *pkt= new_pkt;
425
426 bsfc= bsfc->next;
427 }
428
429 ret= av_interleaved_write_frame(s, pkt);
430 if(ret < 0){
431 print_error("av_interleaved_write_frame()", ret);
432 exit(1);
433 }
434 }
435
436 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
437
438 static void do_audio_out(AVFormatContext *s,
439 AVOutputStream *ost,
440 AVInputStream *ist,
441 unsigned char *buf, int size)
442 {
443 uint8_t *buftmp;
444 static uint8_t *audio_buf = NULL;
445 static uint8_t *audio_out = NULL;
446 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
447
448 int size_out, frame_bytes, ret;
449 AVCodecContext *enc= ost->st->codec;
450
451 /* SC: dynamic allocation of buffers */
452 if (!audio_buf)
453 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
454 if (!audio_out)
455 audio_out = av_malloc(audio_out_size);
456 if (!audio_buf || !audio_out)
457 return; /* Should signal an error ! */
458
459 if(audio_sync_method){
460 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
461 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
462 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
463 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
464
465 //FIXME resample delay
466 if(fabs(delta) > 50){
467 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
468 if(byte_delta < 0){
469 byte_delta= FFMAX(byte_delta, -size);
470 size += byte_delta;
471 buf -= byte_delta;
472 if(verbose > 2)
473 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
474 if(!size)
475 return;
476 ist->is_start=0;
477 }else{
478 static uint8_t *input_tmp= NULL;
479 input_tmp= av_realloc(input_tmp, byte_delta + size);
480
481 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
482 ist->is_start=0;
483 else
484 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
485
486 memset(input_tmp, 0, byte_delta);
487 memcpy(input_tmp + byte_delta, buf, size);
488 buf= input_tmp;
489 size += byte_delta;
490 if(verbose > 2)
491 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
492 }
493 }else if(audio_sync_method>1){
494 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
495 assert(ost->audio_resample);
496 if(verbose > 2)
497 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
498 // 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));
499 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
500 }
501 }
502 }else
503 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
504 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
505
506 if (ost->audio_resample) {
507 buftmp = audio_buf;
508 size_out = audio_resample(ost->resample,
509 (short *)buftmp, (short *)buf,
510 size / (ist->st->codec->channels * 2));
511 size_out = size_out * enc->channels * 2;
512 } else {
513 buftmp = buf;
514 size_out = size;
515 }
516
517 /* now encode as many frames as possible */
518 if (enc->frame_size > 1) {
519 /* output resampled raw samples */
520 av_fifo_write(&ost->fifo, buftmp, size_out);
521
522 frame_bytes = enc->frame_size * 2 * enc->channels;
523
524 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
525 AVPacket pkt;
526 av_init_packet(&pkt);
527
528 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
529 (short *)audio_buf);
530 audio_size += ret;
531 pkt.stream_index= ost->index;
532 pkt.data= audio_out;
533 pkt.size= ret;
534 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
535 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
536 pkt.flags |= PKT_FLAG_KEY;
537 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
538
539 ost->sync_opts += enc->frame_size;
540 }
541 } else {
542 AVPacket pkt;
543 av_init_packet(&pkt);
544
545 ost->sync_opts += size_out / (2 * enc->channels);
546
547 /* output a pcm frame */
548 /* XXX: change encoding codec API to avoid this ? */
549 switch(enc->codec->id) {
550 case CODEC_ID_PCM_S32LE:
551 case CODEC_ID_PCM_S32BE:
552 case CODEC_ID_PCM_U32LE:
553 case CODEC_ID_PCM_U32BE:
554 size_out = size_out << 1;
555 break;
556 case CODEC_ID_PCM_S24LE:
557 case CODEC_ID_PCM_S24BE:
558 case CODEC_ID_PCM_U24LE:
559 case CODEC_ID_PCM_U24BE:
560 case CODEC_ID_PCM_S24DAUD:
561 size_out = size_out / 2 * 3;
562 break;
563 case CODEC_ID_PCM_S16LE:
564 case CODEC_ID_PCM_S16BE:
565 case CODEC_ID_PCM_U16LE:
566 case CODEC_ID_PCM_U16BE:
567 break;
568 default:
569 size_out = size_out >> 1;
570 break;
571 }
572 ret = avcodec_encode_audio(enc, audio_out, size_out,
573 (short *)buftmp);
574 audio_size += ret;
575 pkt.stream_index= ost->index;
576 pkt.data= audio_out;
577 pkt.size= ret;
578 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
579 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
580 pkt.flags |= PKT_FLAG_KEY;
581 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
582 }
583 }
584
585 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
586 {
587 AVCodecContext *dec;
588 AVPicture *picture2;
589 AVPicture picture_tmp;
590 uint8_t *buf = 0;
591
592 dec = ist->st->codec;
593
594 /* deinterlace : must be done before any resize */
595 if (do_deinterlace || using_vhook) {
596 int size;
597
598 /* create temporary picture */
599 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
600 buf = av_malloc(size);
601 if (!buf)
602 return;
603
604 picture2 = &picture_tmp;
605 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
606
607 if (do_deinterlace){
608 if(avpicture_deinterlace(picture2, picture,
609 dec->pix_fmt, dec->width, dec->height) < 0) {
610 /* if error, do not deinterlace */
611 av_free(buf);
612 buf = NULL;
613 picture2 = picture;
614 }
615 } else {
616 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
617 }
618 } else {
619 picture2 = picture;
620 }
621
622 if (ENABLE_VHOOK)
623 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
624 1000000 * ist->pts / AV_TIME_BASE);
625
626 if (picture != picture2)
627 *picture = *picture2;
628 *bufp = buf;
629 }
630
631 /* we begin to correct av delay at this threshold */
632 #define AV_DELAY_MAX 0.100
633
634 static void do_subtitle_out(AVFormatContext *s,
635 AVOutputStream *ost,
636 AVInputStream *ist,
637 AVSubtitle *sub,
638 int64_t pts)
639 {
640 static uint8_t *subtitle_out = NULL;
641 int subtitle_out_max_size = 65536;
642 int subtitle_out_size, nb, i;
643 AVCodecContext *enc;
644 AVPacket pkt;
645
646 if (pts == AV_NOPTS_VALUE) {
647 fprintf(stderr, "Subtitle packets must have a pts\n");
648 return;
649 }
650
651 enc = ost->st->codec;
652
653 if (!subtitle_out) {
654 subtitle_out = av_malloc(subtitle_out_max_size);
655 }
656
657 /* Note: DVB subtitle need one packet to draw them and one other
658 packet to clear them */
659 /* XXX: signal it in the codec context ? */
660 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
661 nb = 2;
662 else
663 nb = 1;
664
665 for(i = 0; i < nb; i++) {
666 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
667 subtitle_out_max_size, sub);
668
669 av_init_packet(&pkt);
670 pkt.stream_index = ost->index;
671 pkt.data = subtitle_out;
672 pkt.size = subtitle_out_size;
673 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
674 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
675 /* XXX: the pts correction is handled here. Maybe handling
676 it in the codec would be better */
677 if (i == 0)
678 pkt.pts += 90 * sub->start_display_time;
679 else
680 pkt.pts += 90 * sub->end_display_time;
681 }
682 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
683 }
684 }
685
686 static int bit_buffer_size= 1024*256;
687 static uint8_t *bit_buffer= NULL;
688
689 static void do_video_out(AVFormatContext *s,
690 AVOutputStream *ost,
691 AVInputStream *ist,
692 AVFrame *in_picture,
693 int *frame_size)
694 {
695 int nb_frames, i, ret;
696 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
697 AVFrame picture_crop_temp, picture_pad_temp;
698 AVCodecContext *enc, *dec;
699
700 avcodec_get_frame_defaults(&picture_crop_temp);
701 avcodec_get_frame_defaults(&picture_pad_temp);
702
703 enc = ost->st->codec;
704 dec = ist->st->codec;
705
706 /* by default, we output a single frame */
707 nb_frames = 1;
708
709 *frame_size = 0;
710
711 if(video_sync_method){
712 double vdelta;
713 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
714 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
715 if (vdelta < -1.1)
716 nb_frames = 0;
717 else if (vdelta > 1.1)
718 nb_frames = lrintf(vdelta);
719 //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);
720 if (nb_frames == 0){
721 ++nb_frames_drop;
722 if (verbose>2)
723 fprintf(stderr, "*** drop!\n");
724 }else if (nb_frames > 1) {
725 nb_frames_dup += nb_frames;
726 if (verbose>2)
727 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
728 }
729 }else
730 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
731
732 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
733 if (nb_frames <= 0)
734 return;
735
736 if (ost->video_crop) {
737 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
738 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
739 return;
740 }
741 formatted_picture = &picture_crop_temp;
742 } else {
743 formatted_picture = in_picture;
744 }
745
746 final_picture = formatted_picture;
747 padding_src = formatted_picture;
748 resampling_dst = &ost->pict_tmp;
749 if (ost->video_pad) {
750 final_picture = &ost->pict_tmp;
751 if (ost->video_resample) {
752 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
753 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
754 return;
755 }
756 resampling_dst = &picture_pad_temp;
757 }
758 }
759
760 if (ost->video_resample) {
761 padding_src = NULL;
762 final_picture = &ost->pict_tmp;
763 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
764 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
765 }
766
767 if (ost->video_pad) {
768 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
769 enc->height, enc->width, enc->pix_fmt,
770 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
771 }
772
773 /* duplicates frame if needed */
774 for(i=0;i<nb_frames;i++) {
775 AVPacket pkt;
776 av_init_packet(&pkt);
777 pkt.stream_index= ost->index;
778
779 if (s->oformat->flags & AVFMT_RAWPICTURE) {
780 /* raw pictures are written as AVPicture structure to
781 avoid any copies. We support temorarily the older
782 method. */
783 AVFrame* old_frame = enc->coded_frame;
784 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
785 pkt.data= (uint8_t *)final_picture;
786 pkt.size= sizeof(AVPicture);
787 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
788 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
789 if(dec->coded_frame && dec->coded_frame->key_frame)
790 pkt.flags |= PKT_FLAG_KEY;
791
792 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
793 enc->coded_frame = old_frame;
794 } else {
795 AVFrame big_picture;
796
797 big_picture= *final_picture;
798 /* better than nothing: use input picture interlaced
799 settings */
800 big_picture.interlaced_frame = in_picture->interlaced_frame;
801 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
802 if(top_field_first == -1)
803 big_picture.top_field_first = in_picture->top_field_first;
804 else
805 big_picture.top_field_first = top_field_first;
806 }
807
808 /* handles sameq here. This is not correct because it may
809 not be a global option */
810 if (same_quality) {
811 big_picture.quality = ist->st->quality;
812 }else
813 big_picture.quality = ost->st->quality;
814 if(!me_threshold)
815 big_picture.pict_type = 0;
816 // big_picture.pts = AV_NOPTS_VALUE;
817 big_picture.pts= ost->sync_opts;
818 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
819 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
820 ret = avcodec_encode_video(enc,
821 bit_buffer, bit_buffer_size,
822 &big_picture);
823 if (ret == -1) {
824 fprintf(stderr, "Video encoding failed\n");
825 exit(1);
826 }
827 //enc->frame_number = enc->real_pict_num;
828 if(ret>0){
829 pkt.data= bit_buffer;
830 pkt.size= ret;
831 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
832 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
833 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
834 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
835 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
836
837 if(enc->coded_frame && enc->coded_frame->key_frame)
838 pkt.flags |= PKT_FLAG_KEY;
839 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
840 *frame_size = ret;
841 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
842 // enc->frame_number-1, enc->real_pict_num, ret,
843 // enc->pict_type);
844 /* if two pass, output log */
845 if (ost->logfile && enc->stats_out) {
846 fprintf(ost->logfile, "%s", enc->stats_out);
847 }
848 }
849 }
850 ost->sync_opts++;
851 ost->frame_number++;
852 }
853 }
854
855 static double psnr(double d){
856 if(d==0) return INFINITY;
857 return -10.0*log(d)/log(10.0);
858 }
859
860 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
861 int frame_size)
862 {
863 AVCodecContext *enc;
864 int frame_number;
865 double ti1, bitrate, avg_bitrate;
866
867 /* this is executed just the first time do_video_stats is called */
868 if (!vstats_file) {
869 vstats_file = fopen(vstats_filename, "w");
870 if (!vstats_file) {
871 perror("fopen");
872 exit(1);
873 }
874 }
875
876 enc = ost->st->codec;
877 if (enc->codec_type == CODEC_TYPE_VIDEO) {
878 frame_number = ost->frame_number;
879 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
880 if (enc->flags&CODEC_FLAG_PSNR)
881 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
882
883 fprintf(vstats_file,"f_size= %6d ", frame_size);
884 /* compute pts value */
885 ti1 = ost->sync_opts * av_q2d(enc->time_base);
886 if (ti1 < 0.01)
887 ti1 = 0.01;
888
889 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
890 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
891 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
892 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
893 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
894 }
895 }
896
897 static void print_report(AVFormatContext **output_files,
898 AVOutputStream **ost_table, int nb_ostreams,
899 int is_last_report)
900 {
901 char buf[1024];
902 AVOutputStream *ost;
903 AVFormatContext *oc, *os;
904 int64_t total_size;
905 AVCodecContext *enc;
906 int frame_number, vid, i;
907 double bitrate, ti1, pts;
908 static int64_t last_time = -1;
909 static int qp_histogram[52];
910
911 if (!is_last_report) {
912 int64_t cur_time;
913 /* display the report every 0.5 seconds */
914 cur_time = av_gettime();
915 if (last_time == -1) {
916 last_time = cur_time;
917 return;
918 }
919 if ((cur_time - last_time) < 500000)
920 return;
921 last_time = cur_time;
922 }
923
924
925 oc = output_files[0];
926
927 total_size = url_fsize(&oc->pb);
928 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
929 total_size= url_ftell(&oc->pb);
930
931 buf[0] = '\0';
932 ti1 = 1e10;
933 vid = 0;
934 for(i=0;i<nb_ostreams;i++) {
935 ost = ost_table[i];
936 os = output_files[ost->file_index];
937 enc = ost->st->codec;
938 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
939 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
940 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
941 }
942 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
943 float t = (av_gettime()-timer_start) / 1000000.0;
944
945 frame_number = ost->frame_number;
946 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
947 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
948 enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
949 if(is_last_report)
950 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
951 if(qp_hist && enc->coded_frame){
952 int j;
953 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
954 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
955 qp_histogram[qp]++;
956 for(j=0; j<32; j++)
957 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
958 }
959 if (enc->flags&CODEC_FLAG_PSNR){
960 int j;
961 double error, error_sum=0;
962 double scale, scale_sum=0;
963 char type[3]= {'Y','U','V'};
964 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
965 for(j=0; j<3; j++){
966 if(is_last_report){
967 error= enc->error[j];
968 scale= enc->width*enc->height*255.0*255.0*frame_number;
969 }else{
970 error= enc->coded_frame->error[j];
971 scale= enc->width*enc->height*255.0*255.0;
972 }
973 if(j) scale/=4;
974 error_sum += error;
975 scale_sum += scale;
976 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
977 }
978 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
979 }
980 vid = 1;
981 }
982 /* compute min output value */
983 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
984 if ((pts < ti1) && (pts > 0))
985 ti1 = pts;
986 }
987 if (ti1 < 0.01)
988 ti1 = 0.01;
989
990 if (verbose || is_last_report) {
991 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
992
993 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
994 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
995 (double)total_size / 1024, ti1, bitrate);
996
997 if (verbose > 1)
998 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
999 nb_frames_dup, nb_frames_drop);
1000
1001 if (verbose >= 0)
1002 fprintf(stderr, "%s \r", buf);
1003
1004 fflush(stderr);
1005 }
1006
1007 if (is_last_report && verbose >= 0){
1008 int64_t raw= audio_size + video_size + extra_size;
1009 fprintf(stderr, "\n");
1010 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1011 video_size/1024.0,
1012 audio_size/1024.0,
1013 extra_size/1024.0,
1014 100.0*(total_size - raw)/raw
1015 );
1016 }
1017 }
1018
1019 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1020 static int output_packet(AVInputStream *ist, int ist_index,
1021 AVOutputStream **ost_table, int nb_ostreams,
1022 const AVPacket *pkt)
1023 {
1024 AVFormatContext *os;
1025 AVOutputStream *ost;
1026 uint8_t *ptr;
1027 int len, ret, i;
1028 uint8_t *data_buf;
1029 int data_size, got_picture;
1030 AVFrame picture;
1031 void *buffer_to_free;
1032 static unsigned int samples_size= 0;
1033 static short *samples= NULL;
1034 AVSubtitle subtitle, *subtitle_to_free;
1035 int got_subtitle;
1036
1037 if(!pkt){
1038 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1039 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1040 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1041 } else {
1042 // assert(ist->pts == ist->next_pts);
1043 }
1044
1045 if (pkt == NULL) {
1046 /* EOF handling */
1047 ptr = NULL;
1048 len = 0;
1049 goto handle_eof;
1050 }
1051
1052 len = pkt->size;
1053 ptr = pkt->data;
1054 while (len > 0) {
1055 handle_eof:
1056 /* decode the packet if needed */
1057 data_buf = NULL; /* fail safe */
1058 data_size = 0;
1059 subtitle_to_free = NULL;
1060 if (ist->decoding_needed) {
1061 switch(ist->st->codec->codec_type) {
1062 case CODEC_TYPE_AUDIO:{
1063 if(pkt)
1064 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1065 data_size= samples_size;
1066 /* XXX: could avoid copy if PCM 16 bits with same
1067 endianness as CPU */
1068 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1069 ptr, len);
1070 if (ret < 0)
1071 goto fail_decode;
1072 ptr += ret;
1073 len -= ret;
1074 /* Some bug in mpeg audio decoder gives */
1075 /* data_size < 0, it seems they are overflows */
1076 if (data_size <= 0) {
1077 /* no audio frame */
1078 continue;
1079 }
1080 data_buf = (uint8_t *)samples;
1081 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1082 (ist->st->codec->sample_rate * ist->st->codec->channels);
1083 break;}
1084 case CODEC_TYPE_VIDEO:
1085 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1086 /* XXX: allocate picture correctly */
1087 avcodec_get_frame_defaults(&picture);
1088
1089 ret = avcodec_decode_video(ist->st->codec,
1090 &picture, &got_picture, ptr, len);
1091 ist->st->quality= picture.quality;
1092 if (ret < 0)
1093 goto fail_decode;
1094 if (!got_picture) {
1095 /* no picture yet */
1096 goto discard_packet;
1097 }
1098 if (ist->st->codec->time_base.num != 0) {
1099 ist->next_pts += ((int64_t)AV_TIME_BASE *
1100 ist->st->codec->time_base.num) /
1101 ist->st->codec->time_base.den;
1102 }
1103 len = 0;
1104 break;
1105 case CODEC_TYPE_SUBTITLE:
1106 ret = avcodec_decode_subtitle(ist->st->codec,
1107 &subtitle, &got_subtitle, ptr, len);
1108 if (ret < 0)
1109 goto fail_decode;
1110 if (!got_subtitle) {
1111 goto discard_packet;
1112 }
1113 subtitle_to_free = &subtitle;
1114 len = 0;
1115 break;
1116 default:
1117 goto fail_decode;
1118 }
1119 } else {
1120 switch(ist->st->codec->codec_type) {
1121 case CODEC_TYPE_AUDIO:
1122 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1123 (ist->st->codec->sample_rate * ist->st->codec->channels);
1124 break;
1125 case CODEC_TYPE_VIDEO:
1126 if (ist->st->codec->time_base.num != 0) {
1127 ist->next_pts += ((int64_t)AV_TIME_BASE *
1128 ist->st->codec->time_base.num) /
1129 ist->st->codec->time_base.den;
1130 }
1131 break;
1132 }
1133 data_buf = ptr;
1134 data_size = len;
1135 ret = len;
1136 len = 0;
1137 }
1138
1139 buffer_to_free = NULL;
1140 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1141 pre_process_video_frame(ist, (AVPicture *)&picture,
1142 &buffer_to_free);
1143 }
1144
1145 // preprocess audio (volume)
1146 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1147 if (audio_volume != 256) {
1148 short *volp;
1149 volp = samples;
1150 for(i=0;i<(data_size / sizeof(short));i++) {
1151 int v = ((*volp) * audio_volume + 128) >> 8;
1152 if (v < -32768) v = -32768;
1153 if (v > 32767) v = 32767;
1154 *volp++ = v;
1155 }
1156 }
1157 }
1158
1159 /* frame rate emulation */
1160 if (ist->st->codec->rate_emu) {
1161 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1162 int64_t now = av_gettime() - ist->start;
1163 if (pts > now)
1164 usleep(pts - now);
1165
1166 ist->frame++;
1167 }
1168
1169 #if 0
1170 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1171 is the one of the next displayed one */
1172 /* XXX: add mpeg4 too ? */
1173 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1174 if (ist->st->codec->pict_type != B_TYPE) {
1175 int64_t tmp;
1176 tmp = ist->last_ip_pts;
1177 ist->last_ip_pts = ist->frac_pts.val;
1178 ist->frac_pts.val = tmp;
1179 }
1180 }
1181 #endif
1182 /* if output time reached then transcode raw format,
1183 encode packets and output them */
1184 if (start_time == 0 || ist->pts >= start_time)
1185 for(i=0;i<nb_ostreams;i++) {
1186 int frame_size;
1187
1188 ost = ost_table[i];
1189 if (ost->source_index == ist_index) {
1190 os = output_files[ost->file_index];
1191
1192 #if 0
1193 printf("%d: got pts=%0.3f %0.3f\n", i,
1194 (double)pkt->pts / AV_TIME_BASE,
1195 ((double)ist->pts / AV_TIME_BASE) -
1196 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1197 #endif
1198 /* set the input output pts pairs */
1199 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1200
1201 if (ost->encoding_needed) {
1202 switch(ost->st->codec->codec_type) {
1203 case CODEC_TYPE_AUDIO:
1204 do_audio_out(os, ost, ist, data_buf, data_size);
1205 break;
1206 case CODEC_TYPE_VIDEO:
1207 do_video_out(os, ost, ist, &picture, &frame_size);
1208 video_size += frame_size;
1209 if (vstats_filename && frame_size)
1210 do_video_stats(os, ost, frame_size);
1211 break;
1212 case CODEC_TYPE_SUBTITLE:
1213 do_subtitle_out(os, ost, ist, &subtitle,
1214 pkt->pts);
1215 break;
1216 default:
1217 abort();
1218 }
1219 } else {
1220 AVFrame avframe; //FIXME/XXX remove this
1221 AVPacket opkt;
1222 av_init_packet(&opkt);
1223
1224 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1225 continue;
1226
1227 /* no reencoding needed : output the packet directly */
1228 /* force the input stream PTS */
1229
1230 avcodec_get_frame_defaults(&avframe);
1231 ost->st->codec->coded_frame= &avframe;
1232 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1233
1234 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1235 audio_size += data_size;
1236 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1237 video_size += data_size;
1238 ost->sync_opts++;
1239 }
1240
1241 opkt.stream_index= ost->index;
1242 if(pkt->pts != AV_NOPTS_VALUE)
1243 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1244 else
1245 opkt.pts= AV_NOPTS_VALUE;
1246
1247 if (pkt->dts == AV_NOPTS_VALUE)
1248 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1249 else
1250 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1251
1252 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1253 opkt.flags= pkt->flags;
1254
1255 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1256 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1257 opkt.destruct= av_destruct_packet;
1258
1259 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1260 ost->st->codec->frame_number++;
1261 ost->frame_number++;
1262 av_free_packet(&opkt);
1263 }
1264 }
1265 }
1266 av_free(buffer_to_free);
1267 /* XXX: allocate the subtitles in the codec ? */
1268 if (subtitle_to_free) {
1269 if (subtitle_to_free->rects != NULL) {
1270 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1271 av_free(subtitle_to_free->rects[i].bitmap);
1272 av_free(subtitle_to_free->rects[i].rgba_palette);
1273 }
1274 av_freep(&subtitle_to_free->rects);
1275 }
1276 subtitle_to_free->num_rects = 0;
1277 subtitle_to_free = NULL;
1278 }
1279 }
1280 discard_packet:
1281 if (pkt == NULL) {
1282 /* EOF handling */
1283
1284 for(i=0;i<nb_ostreams;i++) {
1285 ost = ost_table[i];
1286 if (ost->source_index == ist_index) {
1287 AVCodecContext *enc= ost->st->codec;
1288 os = output_files[ost->file_index];
1289
1290 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1291 continue;
1292 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1293 continue;
1294
1295 if (ost->encoding_needed) {
1296 for(;;) {
1297 AVPacket pkt;
1298 int fifo_bytes;
1299 av_init_packet(&pkt);
1300 pkt.stream_index= ost->index;
1301
1302 switch(ost->st->codec->codec_type) {
1303 case CODEC_TYPE_AUDIO:
1304 fifo_bytes = av_fifo_size(&ost->fifo);
1305 ret = 0;
1306 /* encode any samples remaining in fifo */
1307 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1308 int fs_tmp = enc->frame_size;
1309 enc->frame_size = fifo_bytes / (2 * enc->channels);
1310 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1311 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1312 }
1313 enc->frame_size = fs_tmp;
1314 }
1315 if(ret <= 0) {
1316 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1317 }
1318 audio_size += ret;
1319 pkt.flags |= PKT_FLAG_KEY;
1320 break;
1321 case CODEC_TYPE_VIDEO:
1322 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1323 video_size += ret;
1324 if(enc->coded_frame && enc->coded_frame->key_frame)
1325 pkt.flags |= PKT_FLAG_KEY;
1326 if (ost->logfile && enc->stats_out) {
1327 fprintf(ost->logfile, "%s", enc->stats_out);
1328 }
1329 break;
1330 default:
1331 ret=-1;
1332 }
1333
1334 if(ret<=0)
1335 break;
1336 pkt.data= bit_buffer;
1337 pkt.size= ret;
1338 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1339 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1340 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1341 }
1342 }
1343 }
1344 }
1345 }
1346
1347 return 0;
1348 fail_decode:
1349 return -1;
1350 }
1351
1352 static void print_sdp(AVFormatContext **avc, int n)
1353 {
1354 char sdp[2048];
1355
1356 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1357 printf("SDP:\n%s\n", sdp);
1358 }
1359
1360 static int stream_index_from_inputs(AVFormatContext **input_files,
1361 int nb_input_files,
1362 AVInputFile *file_table,
1363 AVInputStream **ist_table,
1364 enum CodecType type,
1365 int programid)
1366 {
1367 int p, q, z;
1368 for(z=0; z<nb_input_files; z++) {
1369 AVFormatContext *ic = input_files[z];
1370 for(p=0; p<ic->nb_programs; p++) {
1371 AVProgram *program = ic->programs[p];
1372 if(program->id != programid)
1373 continue;
1374 for(q=0; q<program->nb_stream_indexes; q++) {
1375 int sidx = program->stream_index[q];
1376 int ris = file_table[z].ist_index + sidx;
1377 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1378 return ris;
1379 }
1380 }
1381 }
1382
1383 return -1;
1384 }
1385
1386 /*
1387 * The following code is the main loop of the file converter
1388 */
1389 static int av_encode(AVFormatContext **output_files,
1390 int nb_output_files,
1391 AVFormatContext **input_files,
1392 int nb_input_files,
1393 AVStreamMap *stream_maps, int nb_stream_maps)
1394 {
1395 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1396 AVFormatContext *is, *os;
1397 AVCodecContext *codec, *icodec;
1398 AVOutputStream *ost, **ost_table = NULL;
1399 AVInputStream *ist, **ist_table = NULL;
1400 AVInputFile *file_table;
1401 int key;
1402 int want_sdp = 1;
1403
1404 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1405 if (!file_table)
1406 goto fail;
1407
1408 /* input stream init */
1409 j = 0;
1410 for(i=0;i<nb_input_files;i++) {
1411 is = input_files[i];
1412 file_table[i].ist_index = j;
1413 file_table[i].nb_streams = is->nb_streams;
1414 j += is->nb_streams;
1415 }
1416 nb_istreams = j;
1417
1418 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1419 if (!ist_table)
1420 goto fail;
1421
1422 for(i=0;i<nb_istreams;i++) {
1423 ist = av_mallocz(sizeof(AVInputStream));
1424 if (!ist)
1425 goto fail;
1426 ist_table[i] = ist;
1427 }
1428 j = 0;
1429 for(i=0;i<nb_input_files;i++) {
1430 is = input_files[i];
1431 for(k=0;k<is->nb_streams;k++) {
1432 ist = ist_table[j++];
1433 ist->st = is->streams[k];
1434 ist->file_index = i;
1435 ist->index = k;
1436 ist->discard = 1; /* the stream is discarded by default
1437 (changed later) */
1438
1439 if (ist->st->codec->rate_emu) {
1440 ist->start = av_gettime();
1441 ist->frame = 0;
1442 }
1443 }
1444 }
1445
1446 /* output stream init */
1447 nb_ostreams = 0;
1448 for(i=0;i<nb_output_files;i++) {
1449 os = output_files[i];
1450 if (!os->nb_streams) {
1451 fprintf(stderr, "Output file does not contain any stream\n");
1452 exit(1);
1453 }
1454 nb_ostreams += os->nb_streams;
1455 }
1456 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1457 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1458 exit(1);
1459 }
1460
1461 /* Sanity check the mapping args -- do the input files & streams exist? */
1462 for(i=0;i<nb_stream_maps;i++) {
1463 int fi = stream_maps[i].file_index;
1464 int si = stream_maps[i].stream_index;
1465
1466 if (fi < 0 || fi > nb_input_files - 1 ||
1467 si < 0 || si > file_table[fi].nb_streams - 1) {
1468 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1469 exit(1);
1470 }
1471 fi = stream_maps[i].sync_file_index;
1472 si = stream_maps[i].sync_stream_index;
1473 if (fi < 0 || fi > nb_input_files - 1 ||
1474 si < 0 || si > file_table[fi].nb_streams - 1) {
1475 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1476 exit(1);
1477 }
1478 }
1479
1480 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1481 if (!ost_table)
1482 goto fail;
1483 for(i=0;i<nb_ostreams;i++) {
1484 ost = av_mallocz(sizeof(AVOutputStream));
1485 if (!ost)
1486 goto fail;
1487 ost_table[i] = ost;
1488 }
1489
1490 n = 0;
1491 for(k=0;k<nb_output_files;k++) {
1492 os = output_files[k];
1493 for(i=0;i<os->nb_streams;i++) {
1494 int found;
1495 ost = ost_table[n++];
1496 ost->file_index = k;
1497 ost->index = i;
1498 ost->st = os->streams[i];
1499 if (nb_stream_maps > 0) {
1500 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1501 stream_maps[n-1].stream_index;
1502
1503 /* Sanity check that the stream types match */
1504 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1505 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1506 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1507 ost->file_index, ost->index);
1508 exit(1);
1509 }
1510
1511 } else {
1512 if(opt_programid) {
1513 found = 0;
1514 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1515 if(j != -1) {
1516 ost->source_index = j;
1517 found = 1;
1518 }
1519 } else {
1520 /* get corresponding input stream index : we select the first one with the right type */
1521 found = 0;
1522 for(j=0;j<nb_istreams;j++) {
1523 ist = ist_table[j];
1524 if (ist->discard &&
1525 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1526 ost->source_index = j;
1527 found = 1;
1528 break;
1529 }
1530 }
1531 }
1532
1533 if (!found) {
1534 if(! opt_programid) {
1535 /* try again and reuse existing stream */
1536 for(j=0;j<nb_istreams;j++) {
1537 ist = ist_table[j];
1538 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1539 ost->source_index = j;
1540 found = 1;
1541 }
1542 }
1543 }
1544 if (!found) {
1545 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1546 ost->file_index, ost->index);
1547 exit(1);
1548 }
1549 }
1550 }
1551 ist = ist_table[ost->source_index];
1552 ist->discard = 0;
1553 ost->sync_ist = (nb_stream_maps > 0) ?
1554 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1555 stream_maps[n-1].sync_stream_index] : ist;
1556 }
1557 }
1558
1559 /* for each output stream, we compute the right encoding parameters */
1560 for(i=0;i<nb_ostreams;i++) {
1561 ost = ost_table[i];
1562 os = output_files[ost->file_index];
1563 ist = ist_table[ost->source_index];
1564
1565 codec = ost->st->codec;
1566 icodec = ist->st->codec;
1567
1568 if (!ost->st->language[0])
1569 av_strlcpy(ost->st->language, ist->st->language,
1570 sizeof(ost->st->language));
1571
1572 if (ost->st->stream_copy) {
1573 /* if stream_copy is selected, no need to decode or encode */
1574 codec->codec_id = icodec->codec_id;
1575 codec->codec_type = icodec->codec_type;
1576
1577 if(!codec->codec_tag){
1578 if( !os->oformat->codec_tag
1579 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1580 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1581 codec->codec_tag = icodec->codec_tag;
1582 }
1583
1584 codec->bit_rate = icodec->bit_rate;
1585 codec->extradata= icodec->extradata;
1586 codec->extradata_size= icodec->extradata_size;
1587 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1588 codec->time_base = icodec->time_base;
1589 else
1590 codec->time_base = ist->st->time_base;
1591 switch(codec->codec_type) {
1592 case CODEC_TYPE_AUDIO:
1593 codec->sample_rate = icodec->sample_rate;
1594 codec->channels = icodec->channels;
1595 codec->frame_size = icodec->frame_size;
1596 codec->block_align= icodec->block_align;
1597 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1598 codec->block_align= 0;
1599 break;
1600 case CODEC_TYPE_VIDEO:
1601 if(using_vhook) {
1602 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1603 exit(1);
1604 }
1605 codec->pix_fmt = icodec->pix_fmt;
1606 codec->width = icodec->width;
1607 codec->height = icodec->height;
1608 codec->has_b_frames = icodec->has_b_frames;
1609 break;
1610 case CODEC_TYPE_SUBTITLE:
1611 break;
1612 default:
1613 abort();
1614 }
1615 } else {
1616 switch(codec->codec_type) {
1617 case CODEC_TYPE_AUDIO:
1618 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1619 goto fail;
1620
1621 if (codec->channels == icodec->channels &&
1622 codec->sample_rate == icodec->sample_rate) {
1623 ost->audio_resample = 0;
1624 } else {
1625 if (codec->channels != icodec->channels &&
1626 (icodec->codec_id == CODEC_ID_AC3 ||
1627 icodec->codec_id == CODEC_ID_DTS)) {
1628 /* Special case for 5:1 AC3 and DTS input */
1629 /* and mono or stereo output */
1630 /* Request specific number of channels */
1631 icodec->channels = codec->channels;
1632 if (codec->sample_rate == icodec->sample_rate)
1633 ost->audio_resample = 0;
1634 else {
1635 ost->audio_resample = 1;
1636 }
1637 } else {
1638 ost->audio_resample = 1;
1639 }
1640 }
1641 if(audio_sync_method>1)
1642 ost->audio_resample = 1;
1643
1644 if(ost->audio_resample){
1645 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1646 codec->sample_rate, icodec->sample_rate);
1647 if(!ost->resample){
1648 printf("Can't resample. Aborting.\n");
1649 abort();
1650 }
1651 }
1652 ist->decoding_needed = 1;
1653 ost->encoding_needed = 1;
1654 break;
1655 case CODEC_TYPE_VIDEO:
1656 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1657 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1658 ost->video_resample = ((codec->width != icodec->width -
1659 (frame_leftBand + frame_rightBand) +
1660 (frame_padleft + frame_padright)) ||
1661 (codec->height != icodec->height -
1662 (frame_topBand + frame_bottomBand) +
1663 (frame_padtop + frame_padbottom)) ||
1664 (codec->pix_fmt != icodec->pix_fmt));
1665 if (ost->video_crop) {
1666 ost->topBand = frame_topBand;
1667 ost->leftBand = frame_leftBand;
1668 }
1669 if (ost->video_pad) {
1670 ost->padtop = frame_padtop;
1671 ost->padleft = frame_padleft;
1672 ost->padbottom = frame_padbottom;
1673 ost->padright = frame_padright;
1674 if (!ost->video_resample) {
1675 avcodec_get_frame_defaults(&ost->pict_tmp);
1676 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1677 codec->width, codec->height ) )
1678 goto fail;
1679 }
1680 }
1681 if (ost->video_resample) {
1682 avcodec_get_frame_defaults(&ost->pict_tmp);
1683 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1684 codec->width, codec->height ) ) {
1685 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1686 exit(1);
1687 }
1688 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1689 ost->img_resample_ctx = sws_getContext(
1690 icodec->width - (frame_leftBand + frame_rightBand),
1691 icodec->height - (frame_topBand + frame_bottomBand),
1692 icodec->pix_fmt,
1693 codec->width - (frame_padleft + frame_padright),
1694 codec->height - (frame_padtop + frame_padbottom),
1695 codec->pix_fmt,
1696 sws_flags, NULL, NULL, NULL);
1697 if (ost->img_resample_ctx == NULL) {
1698 fprintf(stderr, "Cannot get resampling context\n");
1699 exit(1);
1700 }
1701 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1702 }
1703 ost->encoding_needed = 1;
1704 ist->decoding_needed = 1;
1705 break;
1706 case CODEC_TYPE_SUBTITLE:
1707 ost->encoding_needed = 1;
1708 ist->decoding_needed = 1;
1709 break;
1710 default:
1711 abort();
1712 break;
1713 }
1714 /* two pass mode */
1715 if (ost->encoding_needed &&
1716 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1717 char logfilename[1024];
1718 FILE *f;
1719 int size;
1720 char *logbuffer;
1721
1722 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1723 pass_logfilename ?
1724 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1725 if (codec->flags & CODEC_FLAG_PASS1) {
1726 f = fopen(logfilename, "w");
1727 if (!f) {
1728 perror(logfilename);
1729 exit(1);
1730 }
1731 ost->logfile = f;
1732 } else {
1733 /* read the log file */
1734 f = fopen(logfilename, "r");
1735 if (!f) {
1736 perror(logfilename);
1737 exit(1);
1738 }
1739 fseek(f, 0, SEEK_END);
1740 size = ftell(f);
1741 fseek(f, 0, SEEK_SET);
1742 logbuffer = av_malloc(size + 1);
1743 if (!logbuffer) {
1744 fprintf(stderr, "Could not allocate log buffer\n");
1745 exit(1);
1746 }
1747 size = fread(logbuffer, 1, size, f);
1748 fclose(f);
1749 logbuffer[size] = '\0';
1750 codec->stats_in = logbuffer;
1751 }
1752 }
1753 }
1754 if(codec->codec_type == CODEC_TYPE_VIDEO){
1755 int size= codec->width * codec->height;
1756 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1757 }
1758 }
1759
1760 if (!bit_buffer)
1761 bit_buffer = av_malloc(bit_buffer_size);
1762 if (!bit_buffer)
1763 goto fail;
1764
1765 /* dump the file output parameters - cannot be done before in case
1766 of stream copy */
1767 for(i=0;i<nb_output_files;i++) {
1768 dump_format(output_files[i], i, output_files[i]->filename, 1);
1769 }
1770
1771 /* dump the stream mapping */
1772 if (verbose >= 0) {
1773 fprintf(stderr, "Stream mapping:\n");
1774 for(i=0;i<nb_ostreams;i++) {
1775 ost = ost_table[i];
1776 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1777 ist_table[ost->source_index]->file_index,
1778 ist_table[ost->source_index]->index,
1779 ost->file_index,
1780 ost->index);
1781 if (ost->sync_ist != ist_table[ost->source_index])
1782 fprintf(stderr, " [sync #%d.%d]",
1783 ost->sync_ist->file_index,
1784 ost->sync_ist->index);
1785 fprintf(stderr, "\n");
1786 }
1787 }
1788
1789 /* open each encoder */
1790 for(i=0;i<nb_ostreams;i++) {
1791 ost = ost_table[i];
1792 if (ost->encoding_needed) {
1793 AVCodec *codec;
1794 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1795 if (!codec) {
1796 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1797 ost->file_index, ost->index);
1798 exit(1);
1799 }
1800 if (avcodec_open(ost->st->codec, codec) < 0) {
1801 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1802 ost->file_index, ost->index);
1803 exit(1);
1804 }
1805 extra_size += ost->st->codec->extradata_size;
1806 }
1807 }
1808
1809 /* open each decoder */
1810 for(i=0;i<nb_istreams;i++) {
1811 ist = ist_table[i];
1812 if (ist->decoding_needed) {
1813 AVCodec *codec;
1814 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1815 if (!codec) {
1816 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1817 ist->st->codec->codec_id, ist->file_index, ist->index);
1818 exit(1);
1819 }
1820 if (avcodec_open(ist->st->codec, codec) < 0) {
1821 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1822 ist->file_index, ist->index);
1823 exit(1);
1824 }
1825 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1826 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1827 }
1828 }
1829
1830 /* init pts */
1831 for(i=0;i<nb_istreams;i++) {
1832 ist = ist_table[i];
1833 is = input_files[ist->file_index];
1834 ist->pts = 0;
1835 ist->next_pts=0;
1836 if( input_files_ts_offset[ist->file_index] != -is->start_time
1837 && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1838 ist->next_pts= AV_NOPTS_VALUE;
1839 ist->is_start = 1;
1840 }
1841
1842 /* set meta data information from input file if required */
1843 for (i=0;i<nb_meta_data_maps;i++) {
1844 AVFormatContext *out_file;
1845 AVFormatContext *in_file;
1846
1847 int out_file_index = meta_data_maps[i].out_file;
1848 int in_file_index = meta_data_maps[i].in_file;
1849 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1850 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1851 ret = AVERROR(EINVAL);
1852 goto fail;
1853 }
1854 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1855 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1856 ret = AVERROR(EINVAL);
1857 goto fail;
1858 }
1859
1860 out_file = output_files[out_file_index];
1861 in_file = input_files[in_file_index];
1862
1863 strcpy(out_file->title, in_file->title);
1864 strcpy(out_file->author, in_file->author);
1865 strcpy(out_file->copyright, in_file->copyright);
1866 strcpy(out_file->comment, in_file->comment);
1867 strcpy(out_file->album, in_file->album);
1868 out_file->year = in_file->year;
1869 out_file->track = in_file->track;
1870 strcpy(out_file->genre, in_file->genre);
1871 }
1872
1873 /* open files and write file headers */
1874 for(i=0;i<nb_output_files;i++) {
1875 os = output_files[i];
1876 if (av_write_header(os) < 0) {
1877 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1878 ret = AVERROR(EINVAL);
1879 goto fail;
1880 }
1881 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1882 want_sdp = 0;
1883 }
1884 }
1885 if (want_sdp) {
1886 print_sdp(output_files, nb_output_files);
1887 }
1888
1889 if ( !using_stdin && verbose >= 0) {
1890 fprintf(stderr, "Press [q] to stop encoding\n");
1891 url_set_interrupt_cb(decode_interrupt_cb);
1892 }
1893 term_init();
1894
1895 key = -1;
1896 timer_start = av_gettime();
1897
1898 for(; received_sigterm == 0;) {
1899 int file_index, ist_index;
1900 AVPacket pkt;
1901 double ipts_min;
1902 double opts_min;
1903
1904 redo:
1905 ipts_min= 1e100;
1906 opts_min= 1e100;
1907 /* if 'q' pressed, exits */
1908 if (!using_stdin) {
1909 if (q_pressed)
1910 break;
1911 /* read_key() returns 0 on EOF */
1912 key = read_key();
1913 if (key == 'q')
1914 break;
1915 }
1916
1917 /* select the stream that we must read now by looking at the
1918 smallest output pts */
1919 file_index = -1;
1920 for(i=0;i<nb_ostreams;i++) {
1921 double ipts, opts;
1922 ost = ost_table[i];
1923 os = output_files[ost->file_index];
1924 ist = ist_table[ost->source_index];
1925 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1926 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1927 else
1928 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1929 ipts = (double)ist->pts;
1930 if (!file_table[ist->file_index].eof_reached){
1931 if(ipts < ipts_min) {
1932 ipts_min = ipts;
1933 if(input_sync ) file_index = ist->file_index;
1934 }
1935 if(opts < opts_min) {
1936 opts_min = opts;
1937 if(!input_sync) file_index = ist->file_index;
1938 }
1939 }
1940 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1941 file_index= -1;
1942 break;
1943 }
1944 }
1945 /* if none, if is finished */
1946 if (file_index < 0) {
1947 break;
1948 }
1949
1950 /* finish if recording time exhausted */
1951 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1952 break;
1953
1954 /* finish if limit size exhausted */
1955 if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1956 break;
1957
1958 /* read a frame from it and output it in the fifo */
1959 is = input_files[file_index];
1960 if (av_read_frame(is, &pkt) < 0) {
1961 file_table[file_index].eof_reached = 1;
1962 if (opt_shortest)
1963 break;
1964 else
1965 continue;
1966 }
1967
1968 if (do_pkt_dump) {
1969 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1970 }
1971 /* the following test is needed in case new streams appear
1972 dynamically in stream : we ignore them */
1973 if (pkt.stream_index >= file_table[file_index].nb_streams)
1974 goto discard_packet;
1975 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1976 ist = ist_table[ist_index];
1977 if (ist->discard)
1978 goto discard_packet;
1979
1980 if (pkt.dts != AV_NOPTS_VALUE)
1981 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1982 if (pkt.pts != AV_NOPTS_VALUE)
1983 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1984
1985 // 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);
1986 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1987 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1988 int64_t delta= pkt_dts - ist->next_pts;
1989 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1990 input_files_ts_offset[ist->file_index]-= delta;
1991 if (verbose > 2)
1992 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1993 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1994 if(pkt.pts != AV_NOPTS_VALUE)
1995 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1996 }
1997 }
1998
1999 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2000 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2001
2002 if (verbose >= 0)
2003 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2004 ist->file_index, ist->index);
2005
2006 av_free_packet(&pkt);
2007 goto redo;
2008 }
2009
2010 discard_packet:
2011 av_free_packet(&pkt);
2012
2013 /* dump report by using the output first video and audio streams */
2014 print_report(output_files, ost_table, nb_ostreams, 0);
2015 }
2016
2017 /* at the end of stream, we must flush the decoder buffers */
2018 for(i=0;i<nb_istreams;i++) {
2019 ist = ist_table[i];
2020 if (ist->decoding_needed) {
2021 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2022 }
2023 }
2024
2025 term_exit();
2026
2027 /* write the trailer if needed and close file */
2028 for(i=0;i<nb_output_files;i++) {
2029 os = output_files[i];
2030 av_write_trailer(os);
2031 }
2032
2033 /* dump report by using the first video and audio streams */
2034 print_report(output_files, ost_table, nb_ostreams, 1);
2035
2036 /* close each encoder */
2037 for(i=0;i<nb_ostreams;i++) {
2038 ost = ost_table[i];
2039 if (ost->encoding_needed) {
2040 av_freep(&ost->st->codec->stats_in);
2041 avcodec_close(ost->st->codec);
2042 }
2043 }
2044
2045 /* close each decoder */
2046 for(i=0;i<nb_istreams;i++) {
2047 ist = ist_table[i];
2048 if (ist->decoding_needed) {
2049 avcodec_close(ist->st->codec);
2050 }
2051 }
2052
2053 /* finished ! */
2054
2055 ret = 0;
2056 fail1:
2057 av_freep(&bit_buffer);
2058 av_free(file_table);
2059
2060 if (ist_table) {
2061 for(i=0;i<nb_istreams;i++) {
2062 ist = ist_table[i];
2063 av_free(ist);
2064 }
2065 av_free(ist_table);
2066 }
2067 if (ost_table) {
2068 for(i=0;i<nb_ostreams;i++) {
2069 ost = ost_table[i];
2070 if (ost) {
2071 if (ost->logfile) {
2072 fclose(ost->logfile);
2073 ost->logfile = NULL;
2074 }
2075 av_fifo_free(&ost->fifo); /* works even if fifo is not
2076 initialized but set to zero */
2077 av_free(ost->pict_tmp.data[0]);
2078 if (ost->video_resample)
2079 sws_freeContext(ost->img_resample_ctx);
2080 if (ost->audio_resample)
2081 audio_resample_close(ost->resample);
2082 av_free(ost);
2083 }
2084 }
2085 av_free(ost_table);
2086 }
2087 return ret;
2088 fail:
2089 ret = AVERROR(ENOMEM);
2090 goto fail1;
2091 }
2092
2093 #if 0
2094 int file_read(const char *filename)
2095 {
2096 URLContext *h;
2097 unsigned char buffer[1024];
2098 int len, i;
2099
2100 if (url_open(&h, filename, O_RDONLY) < 0) {
2101 printf("could not open '%s'\n", filename);
2102 return -1;
2103 }
2104 for(;;) {
2105 len = url_read(h, buffer, sizeof(buffer));
2106 if (len <= 0)
2107 break;
2108 for(i=0;i<len;i++) putchar(buffer[i]);
2109 }
2110 url_close(h);
2111 return 0;
2112 }
2113 #endif
2114
2115 static void opt_format(const char *arg)
2116 {
2117 /* compatibility stuff for pgmyuv */
2118 if (!strcmp(arg, "pgmyuv")) {
2119 pgmyuv_compatibility_hack=1;
2120 // opt_image_format(arg);
2121 arg = "image2";
2122 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2123 }
2124
2125 file_iformat = av_find_input_format(arg);
2126 file_oformat = guess_format(arg, NULL, NULL);
2127 if (!file_iformat && !file_oformat) {
2128 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2129 exit(1);
2130 }
2131 }
2132
2133 static void opt_video_rc_eq(char *arg)
2134 {
2135 video_rc_eq = arg;
2136 }
2137
2138 static void opt_video_rc_override_string(char *arg)
2139 {
2140 video_rc_override_string = arg;
2141 }
2142
2143 static void opt_me_threshold(const char *arg)
2144 {
2145 me_threshold = atoi(arg);
2146 }
2147
2148 static void opt_verbose(const char *arg)
2149 {
2150 verbose = atoi(arg);
2151 av_log_level = atoi(arg);
2152 }
2153
2154 static void opt_frame_rate(const char *arg)
2155 {
2156 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2157 fprintf(stderr, "Incorrect frame rate\n");
2158 exit(1);
2159 }
2160 }
2161
2162 static void opt_bitrate(const char *opt, const char *arg)
2163 {
2164 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2165
2166 opt_default(opt, arg);
2167
2168 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2169 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2170 }
2171
2172 static void opt_frame_crop_top(const char *arg)
2173 {
2174 frame_topBand = atoi(arg);
2175 if (frame_topBand < 0) {
2176 fprintf(stderr, "Incorrect top crop size\n");
2177 exit(1);
2178 }
2179 if ((frame_topBand % 2) != 0) {
2180 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2181 exit(1);
2182 }
2183 if ((frame_topBand) >= frame_height){
2184 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2185 exit(1);
2186 }
2187 frame_height -= frame_topBand;
2188 }
2189
2190 static void opt_frame_crop_bottom(const char *arg)
2191 {
2192 frame_bottomBand = atoi(arg);
2193 if (frame_bottomBand < 0) {
2194 fprintf(stderr, "Incorrect bottom crop size\n");
2195 exit(1);
2196 }
2197 if ((frame_bottomBand % 2) != 0) {
2198 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2199 exit(1);
2200 }
2201 if ((frame_bottomBand) >= frame_height){
2202 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2203 exit(1);
2204 }
2205 frame_height -= frame_bottomBand;
2206 }
2207
2208 static void opt_frame_crop_left(const char *arg)
2209 {
2210 frame_leftBand = atoi(arg);
2211 if (frame_leftBand < 0) {
2212 fprintf(stderr, "Incorrect left crop size\n");
2213 exit(1);
2214 }
2215 if ((frame_leftBand % 2) != 0) {
2216 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2217 exit(1);
2218 }
2219 if ((frame_leftBand) >= frame_width){
2220 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2221 exit(1);
2222 }
2223 frame_width -= frame_leftBand;
2224 }
2225
2226 static void opt_frame_crop_right(const char *arg)
2227 {
2228 frame_rightBand = atoi(arg);
2229 if (frame_rightBand < 0) {
2230 fprintf(stderr, "Incorrect right crop size\n");
2231 exit(1);
2232 }
2233 if ((frame_rightBand % 2) != 0) {
2234 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2235 exit(1);
2236 }
2237 if ((frame_rightBand) >= frame_width){
2238 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2239 exit(1);
2240 }
2241 frame_width -= frame_rightBand;
2242 }
2243
2244 static void opt_frame_size(const char *arg)
2245 {
2246 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2247 fprintf(stderr, "Incorrect frame size\n");
2248 exit(1);
2249 }
2250 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2251 fprintf(stderr, "Frame size must be a multiple of 2\n");
2252 exit(1);
2253 }
2254 }
2255
2256
2257 #define SCALEBITS 10
2258 #define ONE_HALF (1 << (SCALEBITS - 1))
2259 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2260
2261 #define RGB_TO_Y(r, g, b) \
2262 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2263 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2264
2265 #define RGB_TO_U(r1, g1, b1, shift)\
2266 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2267 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2268
2269 #define RGB_TO_V(r1, g1, b1, shift)\
2270 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2271 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2272
2273 static void opt_pad_color(const char *arg) {
2274 /* Input is expected to be six hex digits similar to
2275 how colors are expressed in html tags (but without the #) */
2276 int rgb = strtol(arg, NULL, 16);
2277 int r,g,b;
2278
2279 r = (rgb >> 16);
2280 g = ((rgb >> 8) & 255);
2281 b = (rgb & 255);
2282
2283 padcolor[0] = RGB_TO_Y(r,g,b);
2284 padcolor[1] = RGB_TO_U(r,g,b,0);
2285 padcolor[2] = RGB_TO_V(r,g,b,0);
2286 }
2287
2288 static void opt_frame_pad_top(const char *arg)
2289 {
2290 frame_padtop = atoi(arg);
2291 if (frame_padtop < 0) {
2292 fprintf(stderr, "Incorrect top pad size\n");
2293 exit(1);
2294 }
2295 if ((frame_padtop % 2) != 0) {
2296 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2297 exit(1);
2298 }
2299 }
2300
2301 static void opt_frame_pad_bottom(const char *arg)
2302 {
2303 frame_padbottom = atoi(arg);
2304 if (frame_padbottom < 0) {
2305 fprintf(stderr, "Incorrect bottom pad size\n");
2306 exit(1);
2307 }
2308 if ((frame_padbottom % 2) != 0) {
2309 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2310 exit(1);
2311 }
2312 }
2313
2314
2315 static void opt_frame_pad_left(const char *arg)
2316 {
2317 frame_padleft = atoi(arg);
2318 if (frame_padleft < 0) {
2319 fprintf(stderr, "Incorrect left pad size\n");
2320 exit(1);
2321 }
2322 if ((frame_padleft % 2) != 0) {
2323 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2324 exit(1);
2325 }
2326 }
2327
2328
2329 static void opt_frame_pad_right(const char *arg)
2330 {
2331 frame_padright = atoi(arg);
2332 if (frame_padright < 0) {
2333 fprintf(stderr, "Incorrect right pad size\n");
2334 exit(1);
2335 }
2336 if ((frame_padright % 2) != 0) {
2337 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2338 exit(1);
2339 }
2340 }
2341
2342 void list_pix_fmts(void)
2343 {
2344 int i;
2345 char pix_fmt_str[128];
2346 for (i=-1; i < PIX_FMT_NB; i++) {
2347 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2348 fprintf(stdout, "%s\n", pix_fmt_str);
2349 }
2350 }
2351
2352 static void opt_frame_pix_fmt(const char *arg)
2353 {
2354 if (strcmp(arg, "list"))
2355 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2356 else {
2357 list_pix_fmts();
2358 exit(0);
2359 }
2360 }
2361
2362 static void opt_frame_aspect_ratio(const char *arg)
2363 {
2364 int x = 0, y = 0;
2365 double ar = 0;
2366 const char *p;
2367
2368 p = strchr(arg, ':');
2369 if (p) {
2370 x = strtol(arg, (char **)&arg, 10);
2371 if (arg == p)
2372 y = strtol(arg+1, (char **)&arg, 10);
2373 if (x > 0 && y > 0)
2374 ar = (double)x / (double)y;
2375 } else
2376 ar = strtod(arg, (char **)&arg);
2377
2378 if (!ar) {
2379 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2380 exit(1);
2381 }
2382 frame_aspect_ratio = ar;
2383 }
2384
2385 static void opt_qscale(const char *arg)
2386 {
2387 video_qscale = atof(arg);
2388 if (video_qscale <= 0 ||
2389 video_qscale > 255) {
2390 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2391 exit(1);
2392 }
2393 }
2394
2395 static void opt_qdiff(const char *arg)
2396 {
2397 video_qdiff = atoi(arg);
2398 if (video_qdiff < 0 ||
2399 video_qdiff > 31) {
2400 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2401 exit(1);
2402 }
2403 }
2404
2405 static void opt_strict(const char *arg)
2406 {
2407 strict= atoi(arg);
2408 }
2409
2410 static void opt_top_field_first(const char *arg)
2411 {
2412 top_field_first= atoi(arg);
2413 }
2414
2415 static void opt_thread_count(const char *arg)
2416 {
2417 thread_count= atoi(arg);
2418 #if !defined(HAVE_THREADS)
2419 if (verbose >= 0)
2420 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2421 #endif
2422 }
2423
2424 static void opt_audio_rate(const char *arg)
2425 {
2426 audio_sample_rate = atoi(arg);
2427 }
2428
2429 static void opt_audio_channels(const char *arg)
2430 {
2431 audio_channels = atoi(arg);
2432 }
2433
2434 static void opt_video_channel(const char *arg)
2435 {
2436 video_channel = strtol(arg, NULL, 0);
2437 }
2438
2439 static void opt_video_standard(const char *arg)
2440 {
2441 video_standard = av_strdup(arg);
2442 }
2443
2444 static void opt_codec(int *pstream_copy, char **pcodec_name,
2445 int codec_type, const char *arg)
2446 {
2447 av_freep(pcodec_name);
2448 if (!strcmp(arg, "copy")) {
2449 *pstream_copy = 1;
2450 } else {
2451 *pcodec_name = av_strdup(arg);
2452 }
2453 }
2454
2455 static void opt_audio_codec(const char *arg)
2456 {
2457 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2458 }
2459
2460 static void opt_audio_tag(const char *arg)
2461 {
2462 char *tail;
2463 audio_codec_tag= strtol(arg, &tail, 0);
2464
2465 if(!tail || *tail)
2466 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2467 }
2468
2469 static void opt_video_tag(const char *arg)
2470 {
2471 char *tail;
2472 video_codec_tag= strtol(arg, &tail, 0);
2473
2474 if(!tail || *tail)
2475 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2476 }
2477
2478 #ifdef CONFIG_VHOOK
2479 static void add_frame_hooker(const char *arg)
2480 {
2481 int argc = 0;
2482 char *argv[64];
2483 int i;
2484 char *args = av_strdup(arg);
2485
2486 using_vhook = 1;
2487
2488 argv[0] = strtok(args, " ");
2489 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2490 }
2491
2492 i = frame_hook_add(argc, argv);
2493
2494 if (i != 0) {
2495 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2496 exit(1);
2497 }
2498 }
2499 #endif
2500
2501 static void opt_video_codec(const char *arg)
2502 {
2503 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2504 }
2505
2506 static void opt_subtitle_codec(const char *arg)
2507 {
2508 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2509 }
2510
2511 static void opt_map(const char *arg)
2512 {
2513 AVStreamMap *m;
2514 const char *p;
2515
2516 p = arg;
2517 m = &stream_maps[nb_stream_maps++];
2518
2519 m->file_index = strtol(arg, (char **)&p, 0);
2520 if (*p)
2521 p++;
2522
2523 m->stream_index = strtol(p, (char **)&p, 0);
2524 if (*p) {
2525 p++;
2526 m->sync_file_index = strtol(p, (char **)&p, 0);
2527 if (*p)
2528 p++;
2529 m->sync_stream_index = strtol(p, (char **)&p, 0);
2530 } else {
2531 m->sync_file_index = m->file_index;
2532 m->sync_stream_index = m->stream_index;
2533 }
2534 }
2535
2536 static void opt_map_meta_data(const char *arg)
2537 {
2538 AVMetaDataMap *m;
2539 const char *p;
2540
2541 p = arg;
2542 m = &meta_data_maps[nb_meta_data_maps++];
2543
2544 m->out_file = strtol(arg, (char **)&p, 0);
2545 if (*p)
2546 p++;
2547
2548 m->in_file = strtol(p, (char **)&p, 0);
2549 }
2550
2551 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2552 {
2553 int64_t us = parse_date(timestr, is_duration);
2554 if (us == INT64_MIN) {
2555 fprintf(stderr, "Invalid %s specification: %s\n",
2556 is_duration ? "duration" : "date", timestr);
2557 exit(1);
2558 }
2559 return us;
2560 }
2561
2562 static void opt_recording_time(const char *arg)
2563 {
2564 recording_time = parse_time_or_die(arg, 1);
2565 }
2566
2567 static void opt_start_time(const char *arg)
2568 {
2569 start_time = parse_time_or_die(arg, 1);
2570 }
2571
2572 static void opt_rec_timestamp(const char *arg)
2573 {
2574 rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2575 }
2576
2577 static void opt_input_ts_offset(const char *arg)
2578 {
2579 input_ts_offset = parse_time_or_die(arg, 1);
2580 }
2581
2582 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2583 {
2584 char *codec_string = encoder ? "encoder" : "decoder";
2585 AVCodec *codec;
2586
2587 if(!name)
2588 return CODEC_ID_NONE;
2589 codec = encoder ?
2590 avcodec_find_encoder_by_name(name) :
2591 avcodec_find_decoder_by_name(name);
2592 if(!codec) {
2593 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2594 exit(1);
2595 }
2596 if(codec->type != type) {
2597 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2598 exit(1);
2599 }
2600 return codec->id;
2601 }
2602
2603 static void opt_input_file(const char *filename)
2604 {
2605 AVFormatContext *ic;
2606 AVFormatParameters params, *ap = &params;
2607 int err, i, ret, rfps, rfps_base;
2608 int64_t timestamp;
2609
2610 if (!strcmp(filename, "-"))
2611 filename = "pipe:";
2612
2613 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2614 !strcmp( filename, "/dev/stdin" );
2615
2616 /* get default parameters from command line */
2617 ic = av_alloc_format_context();
2618
2619 memset(ap, 0, sizeof(*ap));
2620 ap->prealloced_context = 1;
2621 ap->sample_rate = audio_sample_rate;
2622 ap->channels = audio_channels;
2623 ap->time_base.den = frame_rate.num;
2624 ap->time_base.num = frame_rate.den;
2625 ap->width = frame_width + frame_padleft + frame_padright;
2626 ap->height = frame_height + frame_padtop + frame_padbottom;
2627 ap->pix_fmt = frame_pix_fmt;
2628 ap->channel = video_channel;
2629 ap->standard = video_standard;
2630 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2631 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2632 if(pgmyuv_compatibility_hack)
2633 ap->video_codec_id= CODEC_ID_PGMYUV;
2634
2635 for(i=0; i<opt_name_count; i++){
2636 const AVOption *opt;
2637 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2638 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2639 av_set_double(ic, opt_names[i], d);
2640 }
2641 /* open the input file with generic libav function */
2642 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2643 if (err < 0) {
2644 print_error(filename, err);
2645 exit(1);
2646 }
2647 if(opt_programid) {
2648 int i;
2649 for(i=0; i<ic->nb_programs; i++)
2650 if(ic->programs[i]->id != opt_programid)
2651 ic->programs[i]->discard = AVDISCARD_ALL;
2652 }
2653
2654 ic->loop_input = loop_input;
2655
2656 /* If not enough info to get the stream parameters, we decode the
2657 first frames to get it. (used in mpeg case for example) */
2658 ret = av_find_stream_info(ic);
2659 if (ret < 0 && verbose >= 0) {
2660 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2661 exit(1);
2662 }
2663
2664 timestamp = start_time;
2665 /* add the stream start time */
2666 if (ic->start_time != AV_NOPTS_VALUE)
2667 timestamp += ic->start_time;
2668
2669 /* if seeking requested, we execute it */
2670 if (start_time != 0) {
2671 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2672 if (ret < 0) {
2673 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2674 filename, (double)timestamp / AV_TIME_BASE);
2675 }
2676 /* reset seek info */
2677 start_time = 0;
2678 }
2679
2680 /* update the current parameters so that they match the one of the input stream */
2681 for(i=0;i<ic->nb_streams;i++) {
2682 int j;
2683 AVCodecContext *enc = ic->streams[i]->codec;
2684 if(thread_count>1)
2685 avcodec_thread_init(enc, thread_count);
2686 enc->thread_count= thread_count;
2687 switch(enc->codec_type) {
2688 case CODEC_TYPE_AUDIO:
2689 for(j=0; j<opt_name_count; j++){
2690 const AVOption *opt;
2691 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2692 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2693 av_set_double(enc, opt_names[j], d);
2694 }
2695 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2696 audio_channels = enc->channels;
2697 audio_sample_rate = enc->sample_rate;
2698 if(audio_disable)
2699 ic->streams[i]->discard= AVDISCARD_ALL;
2700 break;
2701 case CODEC_TYPE_VIDEO:
2702 for(j=0; j<opt_name_count; j++){
2703 const AVOption *opt;
2704 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2705 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2706 av_set_double(enc, opt_names[j], d);
2707 }
2708 frame_height = enc->height;
2709 frame_width = enc->width;
2710 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2711 frame_pix_fmt = enc->pix_fmt;
2712 rfps = ic->streams[i]->r_frame_rate.num;
2713 rfps_base = ic->streams[i]->r_frame_rate.den;
2714 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2715 if(me_threshold)
2716 enc->debug |= FF_DEBUG_MV;
2717
2718 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2719
2720 if (verbose >= 0)
2721 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2722 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2723
2724 (float)rfps / rfps_base, rfps, rfps_base);
2725 }
2726 /* update the current frame rate to match the stream frame rate */
2727 frame_rate.num = rfps;
2728 frame_rate.den = rfps_base;
2729
2730 enc->rate_emu = rate_emu;
2731 if(video_disable)
2732 ic->streams[i]->discard= AVDISCARD_ALL;
2733 else if(video_discard)
2734 ic->streams[i]->discard= video_discard;
2735 break;
2736 case CODEC_TYPE_DATA:
2737 break;
2738 case CODEC_TYPE_SUBTITLE:
2739 if(subtitle_disable)
2740 ic->streams[i]->discard = AVDISCARD_ALL;
2741 break;
2742 case CODEC_TYPE_UNKNOWN:
2743 break;
2744 default:
2745 abort();
2746 }
2747 }
2748
2749 input_files[nb_input_files] = ic;
2750 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2751 /* dump the file content */
2752 if (verbose >= 0)
2753 dump_format(ic, nb_input_files, filename, 0);
2754
2755 nb_input_files++;
2756 file_iformat = NULL;
2757 file_oformat = NULL;
2758
2759 video_channel = 0;
2760
2761 rate_emu = 0;
2762 }
2763
2764 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2765 int *has_subtitle_ptr)
2766 {
2767 int has_video, has_audio, has_subtitle, i, j;
2768 AVFormatContext *ic;
2769
2770 has_video = 0;
2771 has_audio = 0;
2772 has_subtitle = 0;
2773 for(j=0;j<nb_input_files;j++) {
2774 ic = input_files[j];
2775 for(i=0;i<ic->nb_streams;i++) {
2776 AVCodecContext *enc = ic->streams[i]->codec;
2777 switch(enc->codec_type) {
2778 case CODEC_TYPE_AUDIO:
2779 has_audio = 1;
2780 break;
2781 case CODEC_TYPE_VIDEO:
2782 has_video = 1;
2783 break;
2784 case CODEC_TYPE_SUBTITLE:
2785 has_subtitle = 1;
2786 break;
2787 case CODEC_TYPE_DATA:
2788 case CODEC_TYPE_UNKNOWN:
2789 break;
2790 default:
2791 abort();
2792 }
2793 }
2794 }
2795 *has_video_ptr = has_video;
2796 *has_audio_ptr = has_audio;
2797 *has_subtitle_ptr = has_subtitle;
2798 }
2799
2800 static void new_video_stream(AVFormatContext *oc)
2801 {
2802 AVStream *st;
2803 AVCodecContext *video_enc;
2804 int codec_id;
2805
2806 st = av_new_stream(oc, oc->nb_streams);
2807 if (!st) {
2808 fprintf(stderr, "Could not alloc stream\n");
2809 exit(1);
2810 }
2811 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2812 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2813 video_bitstream_filters= NULL;
2814
2815 if(thread_count>1)
2816 avcodec_thread_init(st->codec, thread_count);
2817
2818 video_enc = st->codec;
2819
2820 if(video_codec_tag)
2821 video_enc->codec_tag= video_codec_tag;
2822
2823 if( (video_global_header&1)
2824 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2825 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2826 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2827 }
2828 if(video_global_header&2){
2829 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2830 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2831 }
2832
2833 if (video_stream_copy) {
2834 st->stream_copy = 1;
2835 video_enc->codec_type = CODEC_TYPE_VIDEO;
2836 } else {
2837 char *p;
2838 int i;
2839 AVCodec *codec;
2840
2841 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2842 if (video_codec_name)
2843 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2844
2845 video_enc->codec_id = codec_id;
2846 codec = avcodec_find_encoder(codec_id);
2847
2848 for(i=0; i<opt_name_count; i++){
2849 const AVOption *opt;
2850 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2851 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2852 av_set_double(video_enc, opt_names[i], d);
2853 }
2854
2855 video_enc->time_base.den = frame_rate.num;
2856 video_enc->time_base.num = frame_rate.den;
2857 if(codec && codec->supported_framerates){
2858 const AVRational *p= codec->supported_framerates;
2859 AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2860 const AVRational *best=NULL;
2861 AVRational best_error= (AVRational){INT_MAX, 1};
2862 for(; p->den!=0; p++){
2863 AVRational error= av_sub_q(req, *p);
2864 if(error.num <0) error.num *= -1;
2865 if(av_cmp_q(error, best_error) < 0){
2866 best_error= error;
2867 best= p;
2868 }
2869 }
2870 video_enc->time_base.den= best->num;
2871 video_enc->time_base.num= best->den;
2872 }
2873
2874 video_enc->width = frame_width + frame_padright + frame_padleft;
2875 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2876 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2877 video_enc->pix_fmt = frame_pix_fmt;
2878
2879 if(codec && codec->pix_fmts){
2880 const enum PixelFormat *p= codec->pix_fmts;
2881 for(; *p!=-1; p++){
2882 if(*p == video_enc->pix_fmt)
2883 break;
2884 }
2885 if(*p == -1)
2886 video_enc->pix_fmt = codec->pix_fmts[0];
2887 }
2888
2889 if (intra_only)
2890 video_enc->gop_size = 0;
2891 if (video_qscale || same_quality) {
2892 video_enc->flags |= CODEC_FLAG_QSCALE;
2893 video_enc->global_quality=
2894 st->quality = FF_QP2LAMBDA * video_qscale;
2895 }
2896
2897 if(intra_matrix)
2898 video_enc->intra_matrix = intra_matrix;
2899 if(inter_matrix)
2900 video_enc->inter_matrix = inter_matrix;
2901
2902 video_enc->max_qdiff = video_qdiff;
2903 video_enc->rc_eq = video_rc_eq;
2904 video_enc->thread_count = thread_count;
2905 p= video_rc_override_string;
2906 for(i=0; p; i++){
2907 int start, end, q;
2908 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2909 if(e!=3){
2910 fprintf(stderr, "error parsing rc_override\n");
2911 exit(1);
2912 }
2913 video_enc->rc_override=
2914 av_realloc(video_enc->rc_override,
2915 sizeof(RcOverride)*(i+1));
2916 video_enc->rc_override[i].start_frame= start;
2917 video_enc->rc_override[i].end_frame = end;
2918 if(q>0){
2919 video_enc->rc_override[i].qscale= q;
2920 video_enc->rc_override[i].quality_factor= 1.0;
2921 }
2922 else{
2923 video_enc->rc_override[i].qscale= 0;
2924 video_enc->rc_override[i].quality_factor= -q/100.0;
2925 }
2926 p= strchr(p, '/');
2927 if(p) p++;
2928 }
2929 video_enc->rc_override_count=i;
2930 if (!video_enc->rc_initial_buffer_occupancy)
2931 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2932 video_enc->me_threshold= me_threshold;
2933 video_enc->intra_dc_precision= intra_dc_precision - 8;
2934 video_enc->strict_std_compliance = strict;
2935
2936 if (do_psnr)
2937 video_enc->flags|= CODEC_FLAG_PSNR;
2938
2939 /* two pass mode */
2940 if (do_pass) {
2941 if (do_pass == 1) {
2942 video_enc->flags |= CODEC_FLAG_PASS1;
2943 } else {
2944 video_enc->flags |= CODEC_FLAG_PASS2;
2945 }
2946 }
2947 }
2948
2949 /* reset some key parameters */
2950 video_disable = 0;
2951 av_freep(&video_codec_name);
2952 video_stream_copy = 0;
2953 }
2954
2955 static void new_audio_stream(AVFormatContext *oc)
2956 {
2957 AVStream *st;
2958 AVCodecContext *audio_enc;
2959 int codec_id, i;
2960
2961 st = av_new_stream(oc, oc->nb_streams);
2962 if (!st) {
2963 fprintf(stderr, "Could not alloc stream\n");
2964 exit(1);
2965 }
2966 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2967
2968 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2969 audio_bitstream_filters= NULL;
2970
2971 if(thread_count>1)
2972 avcodec_thread_init(st->codec, thread_count);
2973
2974 audio_enc = st->codec;
2975 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2976 audio_enc->strict_std_compliance = strict;
2977
2978 if(audio_codec_tag)
2979 audio_enc->codec_tag= audio_codec_tag;
2980
2981 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2982 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2983 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2984 }
2985 if (audio_stream_copy) {
2986 st->stream_copy = 1;
2987 audio_enc->channels = audio_channels;
2988 } else {
2989 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2990
2991 for(i=0; i<opt_name_count; i++){
2992 const AVOption *opt;
2993 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2994 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2995 av_set_double(audio_enc, opt_names[i], d);
2996 }
2997
2998 if (audio_codec_name)
2999 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3000 audio_enc->codec_id = codec_id;
3001
3002 if (audio_qscale > QSCALE_NONE) {
3003 audio_enc->flags |= CODEC_FLAG_QSCALE;
3004 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3005 }
3006 audio_enc->thread_count = thread_count;
3007 audio_enc->channels = audio_channels;
3008 }
3009 audio_enc->sample_rate = audio_sample_rate;
3010 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3011 if (audio_language) {
3012 av_strlcpy(st->language, audio_language, sizeof(st->language));
3013 av_free(audio_language);
3014 audio_language = NULL;
3015 }
3016
3017 /* reset some key parameters */
3018 audio_disable = 0;
3019 av_freep(&audio_codec_name);
3020 audio_stream_copy = 0;
3021 }
3022
3023 static void new_subtitle_stream(AVFormatContext *oc)
3024 {
3025 AVStream *st;
3026 AVCodecContext *subtitle_enc;
3027 int i;
3028
3029 st = av_new_stream(oc, oc->nb_streams);
3030 if (!st) {
3031 fprintf(stderr, "Could not alloc stream\n");
3032 exit(1);
3033 }
3034 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3035
3036 subtitle_enc = st->codec;
3037 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3038 if (subtitle_stream_copy) {
3039 st->stream_copy = 1;
3040 } else {
3041 for(i=0; i<opt_name_count; i++){
3042 const AVOption *opt;
3043 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
3044 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3045 av_set_double(subtitle_enc, opt_names[i], d);
3046 }
3047 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3048 }
3049
3050 if (subtitle_language) {
3051 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3052 av_free(subtitle_language);
3053 subtitle_language = NULL;
3054 }
3055
3056 subtitle_disable = 0;
3057 av_freep(&subtitle_codec_name);
3058 subtitle_stream_copy = 0;
3059 }
3060
3061 static void opt_new_audio_stream(void)
3062 {
3063 AVFormatContext *oc;
3064 if (nb_output_files <= 0) {
3065 fprintf(stderr, "At least one output file must be specified\n");
3066 exit(1);
3067 }
3068 oc = output_files[nb_output_files - 1];
3069 new_audio_stream(oc);
3070 }
3071
3072 static void opt_new_video_stream(void)
3073 {
3074 AVFormatContext *oc;
3075 if (nb_output_files <= 0) {
3076 fprintf(stderr, "At least one output file must be specified\n");
3077 exit(1);
3078 }
3079 oc = output_files[nb_output_files - 1];
3080 new_video_stream(oc);
3081 }
3082
3083 static void opt_new_subtitle_stream(void)
3084 {
3085 AVFormatContext *oc;
3086 if (nb_output_files <= 0) {
3087 fprintf(stderr, "At least one output file must be specified\n");
3088 exit(1);
3089 }
3090 oc = output_files[nb_output_files - 1];
3091 new_subtitle_stream(oc);
3092 }
3093
3094 static void opt_output_file(const char *filename)
3095 {
3096 AVFormatContext *oc;
3097 int use_video, use_audio, use_subtitle;
3098 int input_has_video, input_has_audio, input_has_subtitle, i;
3099 AVFormatParameters params, *ap = &params;
3100
3101 if (!strcmp(filename, "-"))
3102 filename = "pipe:";
3103
3104 oc = av_alloc_format_context();
3105
3106 if (!file_oformat) {
3107 file_oformat = guess_format(NULL, filename, NULL);
3108 if (!file_oformat) {
3109 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3110 filename);
3111 exit(1);
3112 }
3113 }
3114
3115 oc->oformat = file_oformat;
3116 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3117
3118 if (!strcmp(file_oformat->name, "ffm") &&
3119 av_strstart(filename, "http:", NULL)) {
3120 /* special case for files sent to ffserver: we get the stream
3121 parameters from ffserver */
3122 if (read_ffserver_streams(oc, filename) < 0) {
3123 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3124 exit(1);
3125 }
3126 } else {
3127 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3128 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3129 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3130
3131 /* disable if no corresponding type found and at least one
3132 input file */
3133 if (nb_input_files > 0) {
3134 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3135 &input_has_subtitle);
3136 if (!input_has_video)
3137 use_video = 0;
3138 if (!input_has_audio)
3139 use_audio = 0;
3140 if (!input_has_subtitle)
3141 use_subtitle = 0;
3142 }
3143
3144 /* manual disable */
3145 if (audio_disable) {
3146 use_audio = 0;
3147 }
3148 if (video_disable) {
3149 use_video = 0;
3150 }
3151 if (subtitle_disable) {
3152 use_subtitle = 0;
3153 }
3154
3155 if (use_video) {
3156 new_video_stream(oc);
3157 }
3158
3159 if (use_audio) {
3160 new_audio_stream(oc);
3161 }
3162
3163 if (use_subtitle) {
3164 new_subtitle_stream(oc);
3165 }
3166
3167 oc->timestamp = rec_timestamp;
3168
3169 if (str_title)
3170 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3171 if (str_author)
3172 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3173 if (str_copyright)
3174 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3175 if (str_comment)
3176 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3177 if (str_album)
3178 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3179 }
3180
3181 output_files[nb_output_files++] = oc;
3182
3183 /* check filename in case of an image number is expected */
3184 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3185 if (!av_filename_number_test(oc->filename)) {
3186 print_error(oc->filename, AVERROR_NUMEXPECTED);
3187 exit(1);
3188 }
3189 }
3190
3191 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3192 /* test if it already exists to avoid loosing precious files */
3193 if (!file_overwrite &&
3194 (strchr(filename, ':') == NULL ||
3195 av_strstart(filename, "file:", NULL))) {
3196 if (url_exist(filename)) {
3197 int c;
3198
3199 if ( !using_stdin ) {
3200 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3201 fflush(stderr);
3202 c = getchar();
3203 if (toupper(c) != 'Y') {
3204 fprintf(stderr, "Not overwriting - exiting\n");
3205 exit(1);
3206 }
3207 }
3208 else {
3209 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3210 exit(1);
3211 }
3212 }
3213 }
3214
3215 /* open the file */
3216 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3217 fprintf(stderr, "Could not open '%s'\n", filename);
3218 exit(1);
3219 }
3220 }
3221
3222 memset(ap, 0, sizeof(*ap));
3223 if (av_set_parameters(oc, ap) < 0) {
3224 fprintf(stderr, "%s: Invalid encoding parameters\n",
3225 oc->filename);
3226 exit(1);
3227 }
3228
3229 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3230 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3231 oc->loop_output = loop_output;
3232
3233 for(i=0; i<opt_name_count; i++){
3234 const AVOption *opt;
3235 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3236 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3237 av_set_double(oc, opt_names[i], d);
3238 }
3239
3240 /* reset some options */
3241 file_oformat = NULL;
3242 file_iformat = NULL;
3243 }
3244
3245 /* same option as mencoder */
3246 static void opt_pass(const char *pass_str)
3247 {
3248 int pass;
3249 pass = atoi(pass_str);
3250 if (pass != 1 && pass != 2) {
3251 fprintf(stderr, "pass number can be only 1 or 2\n");
3252 exit(1);
3253 }
3254 do_pass = pass;
3255 }
3256
3257 static int64_t getutime(void)
3258 {
3259 #ifdef HAVE_GETRUSAGE
3260 struct rusage rusage;
3261
3262 getrusage(RUSAGE_SELF, &rusage);
3263 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3264 #elif defined(HAVE_GETPROCESSTIMES)
3265 HANDLE proc;
3266 FILETIME c, e, k, u;
3267 proc = GetCurrentProcess();
3268 GetProcessTimes(proc, &c, &e, &k, &u);
3269 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3270 #else
3271 return av_gettime();
3272 #endif
3273 }
3274
3275 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3276 extern int ffm_nopts;
3277 #endif
3278
3279 static void opt_show_formats(void)
3280 {
3281 AVInputFormat *ifmt;
3282 AVOutputFormat *ofmt;
3283 URLProtocol *up;
3284 AVCodec *p, *p2;
3285 const char *last_name;
3286
3287 printf("File formats:\n");
3288 last_name= "000";
3289 for(;;){
3290 int decode=0;
3291 int encode=0;
3292 const char *name=NULL;
3293 const char *long_name=NULL;
3294
3295 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3296 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3297 strcmp(ofmt->name, last_name)>0){
3298 name= ofmt->name;
3299 long_name= ofmt->long_name;
3300 encode=1;
3301 }
3302 }
3303 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3304 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3305 strcmp(ifmt->name, last_name)>0){
3306 name= ifmt->name;
3307 long_name= ifmt->long_name;
3308 encode=0;
3309 }
3310 if(name && strcmp(ifmt->name, name)==0)
3311 decode=1;
3312 }
3313 if(name==NULL)
3314 break;
3315 last_name= name;
3316
3317 printf(
3318 " %s%s %-15s %s\n",
3319 decode ? "D":" ",
3320 encode ? "E":" ",
3321 name,
3322 long_name ? long_name:" ");
3323 }
3324 printf("\n");
3325
3326 printf("Codecs:\n");
3327 last_name= "000";
3328 for(;;){
3329 int decode=0;
3330 int encode=0;
3331 int cap=0;
3332 const char *type_str;
3333
3334 p2=NULL;
3335 for(p = first_avcodec; p != NULL; p = p->next) {
3336 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3337 strcmp(p->name, last_name)>0){
3338 p2= p;
3339 decode= encode= cap=0;
3340 }
3341 if(p2 && strcmp(p->name, p2->name)==0){
3342 if(p->decode) decode=1;
3343 if(p->encode) encode=1;
3344 cap |= p->capabilities;
3345 }
3346 }
3347 if(p2==NULL)
3348 break;
3349 last_name= p2->name;
3350
3351 switch(p2->type) {
3352 case CODEC_TYPE_VIDEO:
3353 type_str = "V";
3354 break;
3355 case CODEC_TYPE_AUDIO:
3356 type_str = "A";
3357 break;
3358 case CODEC_TYPE_SUBTITLE:
3359 type_str = "S";
3360 break;
3361 default:
3362 type_str = "?";
3363 break;
3364 }
3365 printf(
3366 " %s%s%s%s%s%s %s",
3367 decode ? "D": (/*p2->decoder ? "d":*/" "),
3368 encode ? "E":" ",
3369 type_str,
3370 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3371 cap & CODEC_CAP_DR1 ? "D":" ",
3372 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3373 p2->name);
3374 /* if(p2->decoder && decode==0)
3375 printf(" use %s for decoding", p2->decoder->name);*/
3376 printf("\n");
3377 }
3378 printf("\n");
3379
3380 printf("Supported file protocols:\n");
3381 for(up = first_protocol; up != NULL; up = up->next)
3382 printf(" %s:", up->name);
3383 printf("\n");
3384
3385 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3386 printf("\n");
3387 printf(
3388 "Note, the names of encoders and decoders do not always match, so there are\n"
3389 "several cases where the above table shows encoder only or decoder only entries\n"
3390 "even though both encoding and decoding are supported. For example, the h263\n"
3391 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3392 "worse.\n");
3393 exit(0);
3394 }
3395
3396 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3397 {
3398 int i;
3399 const char *p = str;
3400 for(i = 0;; i++) {
3401 dest[i] = atoi(p);
3402 if(i == 63)
3403 break;
3404 p = strchr(p, ',');
3405 if(!p) {
3406 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3407 exit(1);
3408 }
3409 p++;
3410 }
3411 }
3412
3413 static void opt_inter_matrix(const char *arg)
3414 {
3415 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3416 parse_matrix_coeffs(inter_matrix, arg);
3417 }
3418
3419 static void opt_intra_matrix(const char *arg)
3420 {
3421 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3422 parse_matrix_coeffs(intra_matrix, arg);
3423 }
3424
3425 static void opt_show_help(void)
3426 {
3427 show_help();
3428 exit(0);
3429 }
3430
3431 static void opt_target(const char *arg)
3432 {
3433 int norm = -1;
3434 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3435
3436 if(!strncmp(arg, "pal-", 4)) {
3437 norm = 0;
3438 arg += 4;
3439 } else if(!strncmp(arg, "ntsc-", 5)) {
3440 norm = 1;
3441 arg += 5;
3442 } else if(!strncmp(arg, "film-", 5)) {
3443 norm = 2;
3444 arg += 5;
3445 } else {
3446 int fr;
3447 /* Calculate FR via float to avoid int overflow */
3448 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3449 if(fr == 25000) {
3450 norm = 0;
3451 } else if((fr == 29970) || (fr == 23976)) {
3452 norm = 1;
3453 } else {
3454 /* Try to determine PAL/NTSC by peeking in the input files */
3455 if(nb_input_files) {
3456 int i, j;
3457 for(j = 0; j < nb_input_files; j++) {
3458 for(i = 0; i < input_files[j]->nb_streams; i++) {
3459 AVCodecContext *c = input_files[j]->streams[i]->codec;
3460 if(c->codec_type != CODEC_TYPE_VIDEO)
3461 continue;
3462 fr = c->time_base.den * 1000 / c->time_base.num;
3463 if(fr == 25000) {
3464 norm = 0;
3465 break;
3466 } else if((fr == 29970) || (fr == 23976)) {
3467 norm = 1;
3468 break;
3469 }
3470 }
3471 if(norm >= 0)
3472 break;
3473 }
3474 }
3475 }
3476 if(verbose && norm >= 0)
3477 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3478 }
3479
3480 if(norm < 0) {
3481 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3482 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3483 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3484 exit(1);
3485 }
3486
3487 if(!strcmp(arg, "vcd")) {
3488
3489 opt_video_codec("mpeg1video");
3490 opt_audio_codec("mp2");
3491 opt_format("vcd");
3492
3493 opt_frame_size(norm ? "352x240" : "352x288");
3494 opt_frame_rate(frame_rates[norm]);
3495 opt_default("gop", norm ? "18" : "15");
3496
3497 opt_default("b", "1150000");
3498 opt_default("maxrate", "1150000");
3499 opt_default("minrate", "1150000");
3500 opt_default("bufsize", "327680"); // 40*1024*8;
3501
3502 opt_default("ab", "224000");
3503 audio_sample_rate = 44100;
3504 audio_channels = 2;
3505
3506 opt_default("packetsize", "2324");
3507 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3508
3509 /* We have to offset the PTS, so that it is consistent with the SCR.
3510 SCR starts at 36000, but the first two packs contain only padding
3511 and the first pack from the other stream, respectively, may also have
3512 been written before.
3513 So the real data starts at SCR 36000+3*1200. */
3514 mux_preload= (36000+3*1200) / 90000.0; //0.44
3515 } else if(!strcmp(arg, "svcd")) {
3516
3517 opt_video_codec("mpeg2video");
3518 opt_audio_codec("mp2");
3519 opt_format("svcd");
3520
3521 opt_frame_size(norm ? "480x480" : "480x576");
3522 opt_frame_rate(frame_rates[norm]);
3523 opt_default("gop", norm ? "18" : "15");
3524
3525 opt_default("b", "2040000");
3526 opt_default("maxrate", "2516000");
3527 opt_default("minrate", "0"); //1145000;
3528 opt_default("bufsize", "1835008"); //224*1024*8;
3529 opt_default("flags", "+SCAN_OFFSET");
3530
3531
3532 opt_default("ab", "224000");
3533 audio_sample_rate = 44100;
3534
3535 opt_default("packetsize", "2324");
3536
3537 } else if(!strcmp(arg, "dvd")) {
3538
3539 opt_video_codec("mpeg2video");
3540 opt_audio_codec("ac3");
3541 opt_format("dvd");
3542
3543 opt_frame_size(norm ? "720x480" : "720x576");
3544 opt_frame_rate(frame_rates[norm]);
3545 opt_default("gop", norm ? "18" : "15");
3546
3547 opt_default("b", "6000000");
3548 opt_default("maxrate", "9000000");
3549 opt_default("minrate", "0"); //1500000;
3550 opt_default("bufsize", "1835008"); //224*1024*8;
3551
3552 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3553 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3554
3555 opt_default("ab", "448000");
3556 audio_sample_rate = 48000;
3557
3558 } else if(!strncmp(arg, "dv", 2)) {
3559
3560 opt_format("dv");
3561
3562 opt_frame_size(norm ? "720x480" : "720x576");
3563 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3564 (norm ? "yuv411p" : "yuv420p"));
3565 opt_frame_rate(frame_rates[norm]);
3566
3567 audio_sample_rate = 48000;
3568 audio_channels = 2;
3569
3570 } else {
3571 fprintf(stderr, "Unknown target: %s\n", arg);
3572 exit(1);
3573 }
3574 }
3575
3576 static void opt_vstats_file (const char *arg)
3577 {
3578 av_free (vstats_filename);
3579 vstats_filename=av_strdup (arg);
3580 }
3581
3582 static void opt_vstats (void)
3583 {
3584 char filename[40];
3585 time_t today2 = time(NULL);
3586 struct tm *today = localtime(&today2);
3587
3588 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3589 today->tm_sec);
3590 opt_vstats_file(filename);
3591 }
3592
3593 static void opt_bsf(const char *opt, const char *arg)
3594 {
3595 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3596 AVBitStreamFilterContext **bsfp;
3597
3598 if(!bsfc){
3599 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3600 exit(1);
3601 }
3602
3603 bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3604 while(*bsfp)
3605 bsfp= &(*bsfp)->next;
3606
3607 *bsfp= bsfc;
3608 }
3609
3610 static void opt_show_version(void)
3611 {
3612 show_version(program_name);
3613 exit(0);
3614 }
3615
3616 static int opt_default(const char *opt, const char *arg){
3617 int type;
3618 const AVOption *o= NULL;
3619 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3620
3621 for(type=0; type<CODEC_TYPE_NB; type++){
3622 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3623 if(o2)
3624 o = av_set_string(avctx_opts[type], opt, arg);
3625 }
3626 if(!o)
3627 o = av_set_string(avformat_opts, opt, arg);
3628 if(!o)
3629 o = av_set_string(sws_opts, opt, arg);
3630 if(!o){
3631 if(opt[0] == 'a')
3632 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3633 else if(opt[0] == 'v')
3634 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3635 else if(opt[0] == 's')
3636 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3637 }
3638 if(!o)
3639 return -1;
3640
3641 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3642
3643 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3644 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3645 opt_names[opt_name_count++]= o->name;
3646
3647 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3648 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3649 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3650 ffm_nopts = 1;
3651 #endif
3652
3653 if(avctx_opts[0]->debug)
3654 av_log_level = AV_LOG_DEBUG;
3655 return 0;
3656 }
3657
3658 const OptionDef options[] = {
3659 /* main options */
3660 { "L", 0, {(void*)opt_show_license}, "show license" },
3661 { "h", 0, {(void*)opt_show_help}, "show help" },
3662 { "version", 0, {(void*)opt_show_version}, "show version" },
3663 { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3664 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3665 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3666 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3667 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3668 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3669 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3670 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3671 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3672 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3673 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3674 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3675 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3676 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3677 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3678 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3679 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3680 "add timings for benchmarking" },
3681 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3682 "dump each input packet" },
3683 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3684 "when dumping packets, also dump the payload" },
3685 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3686 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3687 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3688 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3689 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3690 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3691 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3692 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3693 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3694 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3695 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3696 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3697 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3698 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3699
3700 /* video options */
3701 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3702 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3703 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3704 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3705 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3706 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3707 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3708 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3709 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3710 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3711 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3712 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3713 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3714 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3715 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3716 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3717 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3718 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3719 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3720 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3721 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3722 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3723 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3724 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3725 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3726 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3727 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3728 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3729 "use same video quality as source (implies VBR)" },
3730 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3731 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3732 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3733 "deinterlace pictures" },
3734 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3735 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3736 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3737 #ifdef CONFIG_VHOOK
3738 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3739 #endif
3740 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3741 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3742 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3743 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3744 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3745 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3746 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3747
3748 /* audio options */
3749 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3750 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3751 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3752 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3753 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3754 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3755 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3756 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3757 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3758 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3759 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3760
3761 /* subtitle options */
3762 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3763 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3764 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3765 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3766
3767 /* grab options */
3768 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3769 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3770 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3771
3772 /* muxer options */
3773 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3774 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3775
3776 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3777 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3778
3779 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3780 { NULL, },
3781 };
3782
3783 static void opt_show_license(void)
3784 {
3785 show_license();
3786 exit(0);
3787 }
3788
3789 /**
3790 * Trivial log callback.
3791 * Only suitable for show_help and similar since it lacks prefix handling.
3792 */
3793 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3794 {
3795 vfprintf(stdout, fmt, vl);
3796 }
3797
3798 static void show_help(void)
3799 {
3800 av_log_set_callback(log_callback_help);
3801 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3802 "Hyper fast Audio and Video encoder\n");
3803 printf("\n");
3804 show_help_options(options, "Main options:\n",
3805 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3806 show_help_options(options, "\nVideo options:\n",
3807 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3808 OPT_VIDEO);
3809 show_help_options(options, "\nAdvanced Video options:\n",
3810 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3811 OPT_VIDEO | OPT_EXPERT);
3812 show_help_options(options, "\nAudio options:\n",
3813 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3814 OPT_AUDIO);
3815 show_help_options(options, "\nAdvanced Audio options:\n",
3816 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3817 OPT_AUDIO | OPT_EXPERT);
3818 show_help_options(options, "\nSubtitle options:\n",
3819 OPT_SUBTITLE | OPT_GRAB,
3820 OPT_SUBTITLE);
3821 show_help_options(options, "\nAudio/Video grab options:\n",
3822 OPT_GRAB,
3823 OPT_GRAB);
3824 show_help_options(options, "\nAdvanced options:\n",
3825 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3826 OPT_EXPERT);
3827 av_opt_show(avctx_opts[0], NULL);
3828 av_opt_show(avformat_opts, NULL);
3829 av_opt_show(sws_opts, NULL);
3830 }
3831
3832 static int av_exit()
3833 {
3834 int i;
3835
3836 /* close files */
3837 for(i=0;i<nb_output_files;i++) {
3838 /* maybe av_close_output_file ??? */
3839 AVFormatContext *s = output_files[i];
3840 int j;
3841 if (!(s->oformat->flags & AVFMT_NOFILE))
3842 url_fclose(&s->pb);
3843 for(j=0;j<s->nb_streams;j++) {
3844 av_free(s->streams[j]->codec);
3845 av_free(s->streams[j]);
3846 }
3847 av_free(s);
3848 }
3849 for(i=0;i<nb_input_files;i++)
3850 av_close_input_file(input_files[i]);
3851
3852 av_free_static();
3853
3854 av_free(intra_matrix);
3855 av_free(inter_matrix);
3856
3857 if (vstats_file)
3858 fclose(vstats_file);
3859 av_free(vstats_filename);
3860
3861 av_free(opt_names);
3862
3863 av_free(video_codec_name);
3864 av_free(audio_codec_name);
3865 av_free(subtitle_codec_name);
3866
3867 av_free(video_standard);
3868
3869 #ifdef CONFIG_POWERPC_PERF
3870 extern void powerpc_display_perf_report(void);
3871 powerpc_display_perf_report();
3872 #endif /* CONFIG_POWERPC_PERF */
3873
3874 if (received_sigterm) {
3875 fprintf(stderr,
3876 "Received signal %d: terminating.\n",
3877 (int) received_sigterm);
3878 exit (255);
3879 }
3880
3881 exit(0); /* not all OS-es handle main() return value */
3882 return 0;
3883 }
3884
3885 int main(int argc, char **argv)
3886 {
3887 int i;
3888 int64_t ti;
3889
3890 av_register_all();
3891
3892 for(i=0; i<CODEC_TYPE_NB; i++){
3893 avctx_opts[i]= avcodec_alloc_context2(i);
3894 }
3895 avformat_opts = av_alloc_format_context();
3896 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3897
3898 show_banner(program_name, program_birth_year);
3899 if (argc <= 1) {
3900 show_help();
3901 exit(1);
3902 }
3903
3904 /* parse options */
3905 parse_options(argc, argv, options, opt_output_file);
3906
3907 /* file converter / grab */
3908 if (nb_output_files <= 0) {
3909 fprintf(stderr, "Must supply at least one output file\n");
3910 exit(1);
3911 }
3912
3913 if (nb_input_files == 0) {
3914 fprintf(stderr, "Must supply at least one input file\n");
3915 exit(1);
3916 }
3917
3918 ti = getutime();
3919 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3920 stream_maps, nb_stream_maps);
3921 ti = getutime() - ti;
3922 if (do_benchmark) {
3923 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3924 }
3925
3926 return av_exit();
3927 }
lucabe's unfinished and experimental patches for ffmpeg