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