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