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