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