Commit | Line | Data |
---|---|---|
85f07f22 | 1 | /* |
115329f1 | 2 | * FFmpeg main |
01310af2 | 3 | * Copyright (c) 2000-2003 Fabrice Bellard |
85f07f22 | 4 | * |
b78e7197 DB |
5 | * This file is part of FFmpeg. |
6 | * | |
7 | * FFmpeg is free software; you can redistribute it and/or | |
bf5af568 FB |
8 | * modify it under the terms of the GNU Lesser General Public |
9 | * License as published by the Free Software Foundation; either | |
b78e7197 | 10 | * version 2.1 of the License, or (at your option) any later version. |
85f07f22 | 11 | * |
b78e7197 | 12 | * FFmpeg is distributed in the hope that it will be useful, |
85f07f22 | 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
bf5af568 FB |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 | * Lesser General Public License for more details. | |
85f07f22 | 16 | * |
bf5af568 | 17 | * You should have received a copy of the GNU Lesser General Public |
b78e7197 | 18 | * License along with FFmpeg; if not, write to the Free Software |
5509bffa | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
85f07f22 | 20 | */ |
364a9607 | 21 | |
7246177d | 22 | /* needed for usleep() */ |
d0feff2a | 23 | #define _XOPEN_SOURCE 600 |
7246177d | 24 | |
0f4e8165 RB |
25 | #include "config.h" |
26 | #include <ctype.h> | |
27 | #include <string.h> | |
28 | #include <math.h> | |
29 | #include <stdlib.h> | |
30 | #include <errno.h> | |
d86b83f8 | 31 | #include <signal.h> |
22f7a060 | 32 | #include <limits.h> |
7246177d | 33 | #include <unistd.h> |
245976da DB |
34 | #include "libavformat/avformat.h" |
35 | #include "libavdevice/avdevice.h" | |
36 | #include "libswscale/swscale.h" | |
245976da | 37 | #include "libavcodec/opt.h" |
ce1ee094 | 38 | #include "libavcodec/audioconvert.h" |
ecfe3929 | 39 | #include "libavcodec/colorspace.h" |
245976da DB |
40 | #include "libavutil/fifo.h" |
41 | #include "libavutil/avstring.h" | |
42 | #include "libavformat/os_support.h" | |
daf8e955 | 43 | |
b250f9c6 | 44 | #if HAVE_SYS_RESOURCE_H |
0a1b29de | 45 | #include <sys/types.h> |
b091aa44 | 46 | #include <sys/resource.h> |
b250f9c6 | 47 | #elif HAVE_GETPROCESSTIMES |
7495c306 RP |
48 | #include <windows.h> |
49 | #endif | |
50 | ||
b250f9c6 | 51 | #if HAVE_SYS_SELECT_H |
fb1d2d7b BC |
52 | #include <sys/select.h> |
53 | #endif | |
54 | ||
b250f9c6 | 55 | #if HAVE_TERMIOS_H |
85f07f22 FB |
56 | #include <fcntl.h> |
57 | #include <sys/ioctl.h> | |
85f07f22 | 58 | #include <sys/time.h> |
85f07f22 | 59 | #include <termios.h> |
b250f9c6 | 60 | #elif HAVE_CONIO_H |
4b54c6d0 | 61 | #include <conio.h> |
bdc4796f | 62 | #endif |
64c020a8 | 63 | #undef time //needed because HAVE_AV_CONFIG_H is defined on top |
bf5af568 | 64 | #include <time.h> |
85f07f22 | 65 | |
01310af2 FB |
66 | #include "cmdutils.h" |
67 | ||
2b18dcd0 MN |
68 | #undef NDEBUG |
69 | #include <assert.h> | |
70 | ||
c367d067 MN |
71 | #undef exit |
72 | ||
64555bd9 | 73 | const char program_name[] = "FFmpeg"; |
ea9c581f | 74 | const int program_birth_year = 2000; |
86074ed1 | 75 | |
85f07f22 FB |
76 | /* select an input stream for an output stream */ |
77 | typedef struct AVStreamMap { | |
78 | int file_index; | |
79 | int stream_index; | |
b4a3389e WG |
80 | int sync_file_index; |
81 | int sync_stream_index; | |
85f07f22 FB |
82 | } AVStreamMap; |
83 | ||
0a38bafd PB |
84 | /** select an input file for an output file */ |
85 | typedef struct AVMetaDataMap { | |
86 | int out_file; | |
87 | int in_file; | |
88 | } AVMetaDataMap; | |
89 | ||
580a6c57 | 90 | static const OptionDef options[]; |
85f07f22 | 91 | |
85f07f22 FB |
92 | #define MAX_FILES 20 |
93 | ||
ef6fc647 | 94 | static const char *last_asked_format = NULL; |
85f07f22 | 95 | static AVFormatContext *input_files[MAX_FILES]; |
a6a92a9a | 96 | static int64_t input_files_ts_offset[MAX_FILES]; |
8833f375 | 97 | static double input_files_ts_scale[MAX_FILES][MAX_STREAMS]; |
6488cf9b | 98 | static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS]; |
85f07f22 | 99 | static int nb_input_files = 0; |
6488cf9b | 100 | static int nb_icodecs; |
85f07f22 FB |
101 | |
102 | static AVFormatContext *output_files[MAX_FILES]; | |
6488cf9b | 103 | static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS]; |
85f07f22 | 104 | static int nb_output_files = 0; |
6488cf9b | 105 | static int nb_ocodecs; |
85f07f22 | 106 | |
f44fd374 | 107 | static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS]; |
85f07f22 FB |
108 | static int nb_stream_maps; |
109 | ||
0a38bafd PB |
110 | static AVMetaDataMap meta_data_maps[MAX_FILES]; |
111 | static int nb_meta_data_maps; | |
112 | ||
55cf1959 MN |
113 | static int frame_width = 0; |
114 | static int frame_height = 0; | |
880e8ba7 | 115 | static float frame_aspect_ratio = 0; |
644a9262 | 116 | static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE; |
ce1ee094 | 117 | static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE; |
1ff93ffc TK |
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 */ | |
ab6d194a MN |
123 | static int frame_topBand = 0; |
124 | static int frame_bottomBand = 0; | |
125 | static int frame_leftBand = 0; | |
126 | static int frame_rightBand = 0; | |
cf7fc795 | 127 | static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX}; |
89129c6b | 128 | static AVRational frame_rate; |
158c7f05 | 129 | static float video_qscale = 0; |
84f608f4 VM |
130 | static uint16_t *intra_matrix = NULL; |
131 | static uint16_t *inter_matrix = NULL; | |
464a631c | 132 | static const char *video_rc_override_string=NULL; |
85f07f22 | 133 | static int video_disable = 0; |
f3356e9c | 134 | static int video_discard = 0; |
4a897224 | 135 | static char *video_codec_name = NULL; |
b2a2197e | 136 | static int video_codec_tag = 0; |
0fc2c0f6 | 137 | static char *video_language = NULL; |
85f07f22 | 138 | static int same_quality = 0; |
cfcf0ffd | 139 | static int do_deinterlace = 0; |
bb198e19 | 140 | static int top_field_first = -1; |
f4f3223f | 141 | static int me_threshold = 0; |
1a11cbcc | 142 | static int intra_dc_precision = 8; |
5894e1bb | 143 | static int loop_input = 0; |
8108551a | 144 | static int loop_output = AVFMT_NOOUTPUTLOOP; |
0888fd22 | 145 | static int qp_hist = 0; |
85f07f22 | 146 | |
85f07f22 FB |
147 | static int intra_only = 0; |
148 | static int audio_sample_rate = 44100; | |
13367a46 | 149 | static int64_t channel_layout = 0; |
c57c770d JR |
150 | #define QSCALE_NONE -99999 |
151 | static float audio_qscale = QSCALE_NONE; | |
85f07f22 FB |
152 | static int audio_disable = 0; |
153 | static int audio_channels = 1; | |
4a897224 | 154 | static char *audio_codec_name = NULL; |
b2a2197e | 155 | static int audio_codec_tag = 0; |
cf7fc795 FB |
156 | static char *audio_language = NULL; |
157 | ||
11bf3847 | 158 | static int subtitle_disable = 0; |
4a897224 | 159 | static char *subtitle_codec_name = NULL; |
cf7fc795 | 160 | static char *subtitle_language = NULL; |
27ad7d3a | 161 | static int subtitle_codec_tag = 0; |
85f07f22 | 162 | |
17c88cb0 MN |
163 | static float mux_preload= 0.5; |
164 | static float mux_max_delay= 0.7; | |
2db3c638 | 165 | |
fc7ad2af | 166 | static int64_t recording_time = INT64_MAX; |
8831db5c | 167 | static int64_t start_time = 0; |
4568325a | 168 | static int64_t rec_timestamp = 0; |
a6a92a9a | 169 | static int64_t input_ts_offset = 0; |
85f07f22 | 170 | static int file_overwrite = 0; |
a5926d85 AJ |
171 | static int metadata_count; |
172 | static AVMetadataTag *metadata; | |
5727b222 | 173 | static int do_benchmark = 0; |
a0663ba4 | 174 | static int do_hex_dump = 0; |
254abc2e | 175 | static int do_pkt_dump = 0; |
43f1708f | 176 | static int do_psnr = 0; |
5abdb4b1 | 177 | static int do_pass = 0; |
ad16627f | 178 | static char *pass_logfilename_prefix = NULL; |
1629626f FB |
179 | static int audio_stream_copy = 0; |
180 | static int video_stream_copy = 0; | |
cf7fc795 | 181 | static int subtitle_stream_copy = 0; |
8858816d | 182 | static int video_sync_method= -1; |
986ebcdb | 183 | static int audio_sync_method= 0; |
d4d226a8 | 184 | static float audio_drift_threshold= 0.1; |
72bd8100 | 185 | static int copy_ts= 0; |
76bdac6d | 186 | static int opt_shortest = 0; |
90ad92b3 | 187 | static int video_global_header = 0; |
b60d1379 | 188 | static char *vstats_filename; |
032aa7df | 189 | static FILE *vstats_file; |
50e143c4 | 190 | static int opt_programid = 0; |
50e3477f | 191 | static int copy_initial_nonkeyframes = 0; |
5abdb4b1 | 192 | |
bdfcbbed MK |
193 | static int rate_emu = 0; |
194 | ||
a5df11ab | 195 | static int video_channel = 0; |
df0cecdd | 196 | static char *video_standard; |
79a7c268 | 197 | |
a9aa3467 | 198 | static int audio_volume = 256; |
8aa3ee32 | 199 | |
f2abc559 | 200 | static int exit_on_error = 0; |
d9a916e2 | 201 | static int using_stdin = 0; |
f068206e | 202 | static int verbose = 1; |
9c3d33d6 | 203 | static int thread_count= 1; |
b51469a0 | 204 | static int q_pressed = 0; |
1008ceb3 MN |
205 | static int64_t video_size = 0; |
206 | static int64_t audio_size = 0; | |
207 | static int64_t extra_size = 0; | |
a6a92a9a WG |
208 | static int nb_frames_dup = 0; |
209 | static int nb_frames_drop = 0; | |
6e454c38 | 210 | static int input_sync; |
76bdac6d | 211 | static uint64_t limit_filesize = 0; |
d2845b75 | 212 | static int force_fps = 0; |
d9a916e2 | 213 | |
5b6d5596 | 214 | static int pgmyuv_compatibility_hack=0; |
a8482aab | 215 | static float dts_delta_threshold = 10; |
5b6d5596 | 216 | |
e60da588 | 217 | static unsigned int sws_flags = SWS_BICUBIC; |
18a54b04 | 218 | |
29cc1c23 | 219 | static int64_t timer_start; |
8bbf6db9 | 220 | |
3321cb3f BC |
221 | static uint8_t *audio_buf; |
222 | static uint8_t *audio_out; | |
b8919a30 | 223 | unsigned int allocated_audio_out_size, allocated_audio_buf_size; |
3321cb3f BC |
224 | |
225 | static short *samples; | |
226 | ||
748c2fca MN |
227 | static AVBitStreamFilterContext *video_bitstream_filters=NULL; |
228 | static AVBitStreamFilterContext *audio_bitstream_filters=NULL; | |
e1cc8339 | 229 | static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL; |
748c2fca | 230 | static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS]; |
5b6d5596 | 231 | |
ad16627f | 232 | #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass" |
85f07f22 | 233 | |
b4a3389e WG |
234 | struct AVInputStream; |
235 | ||
85f07f22 FB |
236 | typedef struct AVOutputStream { |
237 | int file_index; /* file index */ | |
238 | int index; /* stream index in the output file */ | |
239 | int source_index; /* AVInputStream index */ | |
240 | AVStream *st; /* stream in the output file */ | |
ec5517d5 FB |
241 | int encoding_needed; /* true if encoding needed for this stream */ |
242 | int frame_number; | |
243 | /* input pts and corresponding output pts | |
244 | for A/V sync */ | |
b4a3389e WG |
245 | //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */ |
246 | struct AVInputStream *sync_ist; /* input stream to sync against */ | |
e928649b | 247 | int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number |
85f07f22 | 248 | /* video only */ |
07d0cdfc | 249 | int video_resample; |
a4d36c11 | 250 | AVFrame pict_tmp; /* temporary image for resampling */ |
18a54b04 LA |
251 | struct SwsContext *img_resample_ctx; /* for image resampling */ |
252 | int resample_height; | |
352666c1 | 253 | int resample_width; |
01a3c821 | 254 | int resample_pix_fmt; |
34b10a57 | 255 | |
352666c1 EB |
256 | /* full frame size of first frame */ |
257 | int original_height; | |
258 | int original_width; | |
259 | ||
260 | /* cropping area sizes */ | |
07d0cdfc | 261 | int video_crop; |
352666c1 EB |
262 | int topBand; |
263 | int bottomBand; | |
34b10a57 | 264 | int leftBand; |
352666c1 EB |
265 | int rightBand; |
266 | ||
267 | /* cropping area of first frame */ | |
268 | int original_topBand; | |
269 | int original_bottomBand; | |
270 | int original_leftBand; | |
271 | int original_rightBand; | |
115329f1 | 272 | |
352666c1 | 273 | /* padding area sizes */ |
07d0cdfc | 274 | int video_pad; |
352666c1 | 275 | int padtop; |
1ff93ffc TK |
276 | int padbottom; |
277 | int padleft; | |
278 | int padright; | |
115329f1 | 279 | |
85f07f22 FB |
280 | /* audio only */ |
281 | int audio_resample; | |
282 | ReSampleContext *resample; /* for audio resampling */ | |
a79db0f7 PR |
283 | int reformat_pair; |
284 | AVAudioConvert *reformat_ctx; | |
41dd680d | 285 | AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */ |
5abdb4b1 | 286 | FILE *logfile; |
85f07f22 FB |
287 | } AVOutputStream; |
288 | ||
289 | typedef struct AVInputStream { | |
290 | int file_index; | |
291 | int index; | |
292 | AVStream *st; | |
293 | int discard; /* true if stream data should be discarded */ | |
294 | int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */ | |
0c1a9eda | 295 | int64_t sample_index; /* current sample */ |
bdfcbbed MK |
296 | |
297 | int64_t start; /* time when read started */ | |
254abc2e FB |
298 | int64_t next_pts; /* synthetic pts for cases where pkt.pts |
299 | is not defined */ | |
e7d0374f | 300 | int64_t pts; /* current pts */ |
ff4905a5 | 301 | int is_start; /* is 1 at the start and after a discontinuity */ |
85f07f22 FB |
302 | } AVInputStream; |
303 | ||
304 | typedef struct AVInputFile { | |
305 | int eof_reached; /* true if eof reached */ | |
306 | int ist_index; /* index of first stream in ist_table */ | |
307 | int buffer_size; /* current total buffer size */ | |
79fdaa4c | 308 | int nb_streams; /* nb streams we are aware of */ |
85f07f22 FB |
309 | } AVInputFile; |
310 | ||
b250f9c6 | 311 | #if HAVE_TERMIOS_H |
bdc4796f | 312 | |
85f07f22 FB |
313 | /* init terminal so that we can grab keys */ |
314 | static struct termios oldtty; | |
d86b83f8 | 315 | #endif |
85f07f22 FB |
316 | |
317 | static void term_exit(void) | |
318 | { | |
b250f9c6 | 319 | #if HAVE_TERMIOS_H |
85f07f22 | 320 | tcsetattr (0, TCSANOW, &oldtty); |
d86b83f8 | 321 | #endif |
85f07f22 FB |
322 | } |
323 | ||
e9a832e5 | 324 | static volatile int received_sigterm = 0; |
9680a722 RP |
325 | |
326 | static void | |
327 | sigterm_handler(int sig) | |
328 | { | |
329 | received_sigterm = sig; | |
330 | term_exit(); | |
331 | } | |
332 | ||
85f07f22 FB |
333 | static void term_init(void) |
334 | { | |
b250f9c6 | 335 | #if HAVE_TERMIOS_H |
85f07f22 FB |
336 | struct termios tty; |
337 | ||
338 | tcgetattr (0, &tty); | |
339 | oldtty = tty; | |
340 | ||
341 | tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP | |
342 | |INLCR|IGNCR|ICRNL|IXON); | |
343 | tty.c_oflag |= OPOST; | |
344 | tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); | |
345 | tty.c_cflag &= ~(CSIZE|PARENB); | |
346 | tty.c_cflag |= CS8; | |
347 | tty.c_cc[VMIN] = 1; | |
348 | tty.c_cc[VTIME] = 0; | |
115329f1 | 349 | |
85f07f22 | 350 | tcsetattr (0, TCSANOW, &tty); |
d86b83f8 RP |
351 | signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */ |
352 | #endif | |
85f07f22 | 353 | |
9680a722 | 354 | signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */ |
9680a722 RP |
355 | signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */ |
356 | /* | |
357 | register a function to be called at normal program termination | |
358 | */ | |
85f07f22 | 359 | atexit(term_exit); |
b250f9c6 | 360 | #if CONFIG_BEOS_NETSERVER |
9ddd71fc FR |
361 | fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK); |
362 | #endif | |
85f07f22 FB |
363 | } |
364 | ||
365 | /* read a key without blocking */ | |
366 | static int read_key(void) | |
367 | { | |
b250f9c6 | 368 | #if HAVE_TERMIOS_H |
9ddd71fc | 369 | int n = 1; |
85f07f22 | 370 | unsigned char ch; |
b250f9c6 | 371 | #if !CONFIG_BEOS_NETSERVER |
9ddd71fc | 372 | struct timeval tv; |
85f07f22 FB |
373 | fd_set rfds; |
374 | ||
375 | FD_ZERO(&rfds); | |
376 | FD_SET(0, &rfds); | |
377 | tv.tv_sec = 0; | |
378 | tv.tv_usec = 0; | |
379 | n = select(1, &rfds, NULL, NULL, &tv); | |
9ddd71fc | 380 | #endif |
85f07f22 | 381 | if (n > 0) { |
cb09b2ed PG |
382 | n = read(0, &ch, 1); |
383 | if (n == 1) | |
85f07f22 | 384 | return ch; |
cb09b2ed PG |
385 | |
386 | return n; | |
85f07f22 | 387 | } |
b250f9c6 | 388 | #elif HAVE_CONIO_H |
4b54c6d0 RP |
389 | if(kbhit()) |
390 | return(getch()); | |
d86b83f8 | 391 | #endif |
85f07f22 FB |
392 | return -1; |
393 | } | |
394 | ||
b51469a0 LS |
395 | static int decode_interrupt_cb(void) |
396 | { | |
397 | return q_pressed || (q_pressed = read_key() == 'q'); | |
398 | } | |
399 | ||
296df4e7 | 400 | static int av_exit(int ret) |
e5295c0d RP |
401 | { |
402 | int i; | |
403 | ||
404 | /* close files */ | |
405 | for(i=0;i<nb_output_files;i++) { | |
406 | /* maybe av_close_output_file ??? */ | |
407 | AVFormatContext *s = output_files[i]; | |
408 | int j; | |
8767060c | 409 | if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb) |
e5295c0d RP |
410 | url_fclose(s->pb); |
411 | for(j=0;j<s->nb_streams;j++) { | |
094d9df7 | 412 | av_metadata_free(&s->streams[j]->metadata); |
e5295c0d RP |
413 | av_free(s->streams[j]->codec); |
414 | av_free(s->streams[j]); | |
415 | } | |
094d9df7 AJ |
416 | for(j=0;j<s->nb_programs;j++) { |
417 | av_metadata_free(&s->programs[j]->metadata); | |
418 | } | |
419 | for(j=0;j<s->nb_chapters;j++) { | |
420 | av_metadata_free(&s->chapters[j]->metadata); | |
421 | } | |
422 | av_metadata_free(&s->metadata); | |
e5295c0d RP |
423 | av_free(s); |
424 | } | |
425 | for(i=0;i<nb_input_files;i++) | |
426 | av_close_input_file(input_files[i]); | |
427 | ||
e5295c0d RP |
428 | av_free(intra_matrix); |
429 | av_free(inter_matrix); | |
430 | ||
431 | if (vstats_file) | |
432 | fclose(vstats_file); | |
433 | av_free(vstats_filename); | |
434 | ||
435 | av_free(opt_names); | |
436 | ||
437 | av_free(video_codec_name); | |
438 | av_free(audio_codec_name); | |
439 | av_free(subtitle_codec_name); | |
440 | ||
441 | av_free(video_standard); | |
442 | ||
b250f9c6 | 443 | #if CONFIG_POWERPC_PERF |
9686df2b | 444 | void powerpc_display_perf_report(void); |
e5295c0d RP |
445 | powerpc_display_perf_report(); |
446 | #endif /* CONFIG_POWERPC_PERF */ | |
447 | ||
5973490a BC |
448 | for (i=0;i<CODEC_TYPE_NB;i++) |
449 | av_free(avcodec_opts[i]); | |
450 | av_free(avformat_opts); | |
451 | av_free(sws_opts); | |
3321cb3f BC |
452 | av_free(audio_buf); |
453 | av_free(audio_out); | |
b8919a30 | 454 | allocated_audio_buf_size= allocated_audio_out_size= 0; |
3321cb3f | 455 | av_free(samples); |
5973490a | 456 | |
e5295c0d RP |
457 | if (received_sigterm) { |
458 | fprintf(stderr, | |
459 | "Received signal %d: terminating.\n", | |
460 | (int) received_sigterm); | |
461 | exit (255); | |
462 | } | |
463 | ||
296df4e7 RP |
464 | exit(ret); /* not all OS-es handle main() return value */ |
465 | return ret; | |
e5295c0d RP |
466 | } |
467 | ||
b29f97d1 | 468 | static int read_ffserver_streams(AVFormatContext *s, const char *filename) |
85f07f22 | 469 | { |
79fdaa4c | 470 | int i, err; |
85f07f22 | 471 | AVFormatContext *ic; |
3438d82d | 472 | int nopts = 0; |
85f07f22 | 473 | |
79fdaa4c FB |
474 | err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL); |
475 | if (err < 0) | |
476 | return err; | |
85f07f22 FB |
477 | /* copy stream format */ |
478 | s->nb_streams = ic->nb_streams; | |
479 | for(i=0;i<ic->nb_streams;i++) { | |
480 | AVStream *st; | |
1e491e29 | 481 | |
f37f8d4c | 482 | // FIXME: a more elegant solution is needed |
e1031171 | 483 | st = av_mallocz(sizeof(AVStream)); |
85f07f22 | 484 | memcpy(st, ic->streams[i], sizeof(AVStream)); |
f37f8d4c | 485 | st->codec = avcodec_alloc_context(); |
7ef61879 RP |
486 | if (!st->codec) { |
487 | print_error(filename, AVERROR(ENOMEM)); | |
488 | av_exit(1); | |
489 | } | |
f37f8d4c | 490 | memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext)); |
85f07f22 | 491 | s->streams[i] = st; |
837d248d BC |
492 | |
493 | if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy) | |
494 | st->stream_copy = 1; | |
495 | else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy) | |
496 | st->stream_copy = 1; | |
497 | ||
dbedf2aa BC |
498 | if(!st->codec->thread_count) |
499 | st->codec->thread_count = 1; | |
500 | if(st->codec->thread_count>1) | |
501 | avcodec_thread_init(st->codec, st->codec->thread_count); | |
502 | ||
3438d82d BC |
503 | if(st->codec->flags & CODEC_FLAG_BITEXACT) |
504 | nopts = 1; | |
85f07f22 FB |
505 | } |
506 | ||
3438d82d BC |
507 | if (!nopts) |
508 | s->timestamp = av_gettime(); | |
509 | ||
85f07f22 FB |
510 | av_close_input_file(ic); |
511 | return 0; | |
512 | } | |
513 | ||
b4a3389e WG |
514 | static double |
515 | get_sync_ipts(const AVOutputStream *ost) | |
516 | { | |
517 | const AVInputStream *ist = ost->sync_ist; | |
fec401f7 | 518 | return (double)(ist->pts - start_time)/AV_TIME_BASE; |
b4a3389e WG |
519 | } |
520 | ||
748c2fca | 521 | static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){ |
0ac07031 MN |
522 | int ret; |
523 | ||
748c2fca MN |
524 | while(bsfc){ |
525 | AVPacket new_pkt= *pkt; | |
526 | int a= av_bitstream_filter_filter(bsfc, avctx, NULL, | |
527 | &new_pkt.data, &new_pkt.size, | |
528 | pkt->data, pkt->size, | |
529 | pkt->flags & PKT_FLAG_KEY); | |
7055cdac | 530 | if(a>0){ |
748c2fca MN |
531 | av_free_packet(pkt); |
532 | new_pkt.destruct= av_destruct_packet; | |
7055cdac | 533 | } else if(a<0){ |
1f8e32cd DB |
534 | fprintf(stderr, "%s failed for stream %d, codec %s", |
535 | bsfc->filter->name, pkt->stream_index, | |
536 | avctx->codec ? avctx->codec->name : "copy"); | |
7055cdac | 537 | print_error("", a); |
f2abc559 BC |
538 | if (exit_on_error) |
539 | av_exit(1); | |
748c2fca MN |
540 | } |
541 | *pkt= new_pkt; | |
542 | ||
543 | bsfc= bsfc->next; | |
544 | } | |
545 | ||
0ac07031 MN |
546 | ret= av_interleaved_write_frame(s, pkt); |
547 | if(ret < 0){ | |
548 | print_error("av_interleaved_write_frame()", ret); | |
296df4e7 | 549 | av_exit(1); |
0ac07031 | 550 | } |
748c2fca MN |
551 | } |
552 | ||
817b23ff | 553 | #define MAX_AUDIO_PACKET_SIZE (128 * 1024) |
85f07f22 | 554 | |
115329f1 DB |
555 | static void do_audio_out(AVFormatContext *s, |
556 | AVOutputStream *ost, | |
85f07f22 FB |
557 | AVInputStream *ist, |
558 | unsigned char *buf, int size) | |
559 | { | |
0c1a9eda | 560 | uint8_t *buftmp; |
15bfe412 | 561 | int64_t audio_out_size, audio_buf_size; |
d66c7abc | 562 | |
85f07f22 | 563 | int size_out, frame_bytes, ret; |
01f4895c | 564 | AVCodecContext *enc= ost->st->codec; |
2886f311 | 565 | AVCodecContext *dec= ist->st->codec; |
287ba997 PR |
566 | int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8; |
567 | int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8; | |
15bfe412 MN |
568 | const int coded_bps = av_get_bits_per_sample(enc->codec->id); |
569 | ||
570 | audio_buf_size= (size + isize*dec->channels - 1) / (isize*dec->channels); | |
571 | audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate; | |
8b484d0f | 572 | audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API |
15bfe412 MN |
573 | audio_buf_size*= osize*enc->channels; |
574 | ||
575 | audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels); | |
576 | if(coded_bps > 8*osize) | |
577 | audio_out_size= audio_out_size * coded_bps / (8*osize); | |
578 | audio_out_size += FF_MIN_BUFFER_SIZE; | |
579 | ||
580 | if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){ | |
581 | fprintf(stderr, "Buffer sizes too large\n"); | |
582 | av_exit(1); | |
583 | } | |
85f07f22 | 584 | |
b8919a30 MN |
585 | av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size); |
586 | av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size); | |
e185a2f6 MN |
587 | if (!audio_buf || !audio_out){ |
588 | fprintf(stderr, "Out of memory in do_audio_out\n"); | |
589 | av_exit(1); | |
590 | } | |
d66c7abc | 591 | |
2886f311 AĂ– |
592 | if (enc->channels != dec->channels) |
593 | ost->audio_resample = 1; | |
594 | ||
595 | if (ost->audio_resample && !ost->resample) { | |
d1e3c6fd BC |
596 | if (dec->sample_fmt != SAMPLE_FMT_S16) |
597 | fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n"); | |
598 | ost->resample = av_audio_resample_init(enc->channels, dec->channels, | |
599 | enc->sample_rate, dec->sample_rate, | |
600 | enc->sample_fmt, dec->sample_fmt, | |
601 | 16, 10, 0, 0.8); | |
2886f311 AĂ– |
602 | if (!ost->resample) { |
603 | fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n", | |
604 | dec->channels, dec->sample_rate, | |
605 | enc->channels, enc->sample_rate); | |
296df4e7 | 606 | av_exit(1); |
2886f311 AĂ– |
607 | } |
608 | } | |
609 | ||
a79db0f7 | 610 | #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b)) |
d1e3c6fd | 611 | if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt && |
a79db0f7 | 612 | MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) { |
a79db0f7 PR |
613 | if (ost->reformat_ctx) |
614 | av_audio_convert_free(ost->reformat_ctx); | |
615 | ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1, | |
616 | dec->sample_fmt, 1, NULL, 0); | |
617 | if (!ost->reformat_ctx) { | |
618 | fprintf(stderr, "Cannot convert %s sample format to %s sample format\n", | |
619 | avcodec_get_sample_fmt_name(dec->sample_fmt), | |
620 | avcodec_get_sample_fmt_name(enc->sample_fmt)); | |
621 | av_exit(1); | |
622 | } | |
623 | ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt); | |
624 | } | |
625 | ||
986ebcdb | 626 | if(audio_sync_method){ |
115329f1 | 627 | double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts |
41dd680d | 628 | - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); |
01f4895c MN |
629 | double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate; |
630 | int byte_delta= ((int)idelta)*2*ist->st->codec->channels; | |
ff4905a5 | 631 | |
986ebcdb MN |
632 | //FIXME resample delay |
633 | if(fabs(delta) > 50){ | |
d4d226a8 | 634 | if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){ |
ff4905a5 | 635 | if(byte_delta < 0){ |
f41dd5aa | 636 | byte_delta= FFMAX(byte_delta, -size); |
ff4905a5 MN |
637 | size += byte_delta; |
638 | buf -= byte_delta; | |
639 | if(verbose > 2) | |
640 | fprintf(stderr, "discarding %d audio samples\n", (int)-delta); | |
641 | if(!size) | |
642 | return; | |
643 | ist->is_start=0; | |
644 | }else{ | |
645 | static uint8_t *input_tmp= NULL; | |
646 | input_tmp= av_realloc(input_tmp, byte_delta + size); | |
647 | ||
648 | if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE) | |
649 | ist->is_start=0; | |
650 | else | |
651 | byte_delta= MAX_AUDIO_PACKET_SIZE - size; | |
652 | ||
653 | memset(input_tmp, 0, byte_delta); | |
654 | memcpy(input_tmp + byte_delta, buf, size); | |
655 | buf= input_tmp; | |
656 | size += byte_delta; | |
657 | if(verbose > 2) | |
658 | fprintf(stderr, "adding %d audio samples of silence\n", (int)delta); | |
659 | } | |
660 | }else if(audio_sync_method>1){ | |
f66e4f5f | 661 | int comp= av_clip(delta, -audio_sync_method, audio_sync_method); |
ff4905a5 MN |
662 | assert(ost->audio_resample); |
663 | if(verbose > 2) | |
664 | fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate); | |
41dd680d | 665 | // 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)); |
ff4905a5 MN |
666 | av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate); |
667 | } | |
115329f1 | 668 | } |
986ebcdb | 669 | }else |
b4a3389e | 670 | ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate) |
41dd680d | 671 | - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong |
85f07f22 FB |
672 | |
673 | if (ost->audio_resample) { | |
674 | buftmp = audio_buf; | |
115329f1 | 675 | size_out = audio_resample(ost->resample, |
85f07f22 | 676 | (short *)buftmp, (short *)buf, |
287ba997 PR |
677 | size / (ist->st->codec->channels * isize)); |
678 | size_out = size_out * enc->channels * osize; | |
85f07f22 FB |
679 | } else { |
680 | buftmp = buf; | |
681 | size_out = size; | |
682 | } | |
683 | ||
d1e3c6fd | 684 | if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) { |
a79db0f7 | 685 | const void *ibuf[6]= {buftmp}; |
80f47250 | 686 | void *obuf[6]= {audio_buf}; |
287ba997 PR |
687 | int istride[6]= {isize}; |
688 | int ostride[6]= {osize}; | |
a79db0f7 PR |
689 | int len= size_out/istride[0]; |
690 | if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) { | |
691 | printf("av_audio_convert() failed\n"); | |
f2abc559 BC |
692 | if (exit_on_error) |
693 | av_exit(1); | |
a79db0f7 PR |
694 | return; |
695 | } | |
80f47250 | 696 | buftmp = audio_buf; |
287ba997 | 697 | size_out = len*osize; |
a79db0f7 PR |
698 | } |
699 | ||
85f07f22 | 700 | /* now encode as many frames as possible */ |
a0663ba4 | 701 | if (enc->frame_size > 1) { |
85f07f22 | 702 | /* output resampled raw samples */ |
41dd680d | 703 | if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) { |
745b39d5 SS |
704 | fprintf(stderr, "av_fifo_realloc2() failed\n"); |
705 | av_exit(1); | |
706 | } | |
41dd680d | 707 | av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL); |
85f07f22 | 708 | |
287ba997 | 709 | frame_bytes = enc->frame_size * osize * enc->channels; |
115329f1 | 710 | |
41dd680d | 711 | while (av_fifo_size(ost->fifo) >= frame_bytes) { |
e928649b MN |
712 | AVPacket pkt; |
713 | av_init_packet(&pkt); | |
714 | ||
3898eed8 | 715 | av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL); |
0871ae1a | 716 | |
5bc440e7 MN |
717 | //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio() |
718 | ||
115329f1 | 719 | ret = avcodec_encode_audio(enc, audio_out, audio_out_size, |
a0663ba4 | 720 | (short *)audio_buf); |
528271ff MN |
721 | if (ret < 0) { |
722 | fprintf(stderr, "Audio encoding failed\n"); | |
723 | av_exit(1); | |
724 | } | |
1008ceb3 | 725 | audio_size += ret; |
e928649b MN |
726 | pkt.stream_index= ost->index; |
727 | pkt.data= audio_out; | |
728 | pkt.size= ret; | |
e7902f20 | 729 | if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) |
c0df9d75 | 730 | pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); |
e928649b | 731 | pkt.flags |= PKT_FLAG_KEY; |
748c2fca | 732 | write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); |
115329f1 | 733 | |
986ebcdb | 734 | ost->sync_opts += enc->frame_size; |
85f07f22 FB |
735 | } |
736 | } else { | |
e928649b MN |
737 | AVPacket pkt; |
738 | av_init_packet(&pkt); | |
986ebcdb | 739 | |
287ba997 | 740 | ost->sync_opts += size_out / (osize * enc->channels); |
986ebcdb | 741 | |
a0663ba4 | 742 | /* output a pcm frame */ |
287ba997 PR |
743 | /* determine the size of the coded buffer */ |
744 | size_out /= osize; | |
745 | if (coded_bps) | |
060b8592 | 746 | size_out = size_out*coded_bps/8; |
287ba997 | 747 | |
5ee05a62 MN |
748 | if(size_out > audio_out_size){ |
749 | fprintf(stderr, "Internal error, buffer size too small\n"); | |
750 | av_exit(1); | |
751 | } | |
752 | ||
5bc440e7 | 753 | //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio() |
115329f1 | 754 | ret = avcodec_encode_audio(enc, audio_out, size_out, |
bb270c08 | 755 | (short *)buftmp); |
528271ff MN |
756 | if (ret < 0) { |
757 | fprintf(stderr, "Audio encoding failed\n"); | |
758 | av_exit(1); | |
759 | } | |
1008ceb3 | 760 | audio_size += ret; |
e928649b MN |
761 | pkt.stream_index= ost->index; |
762 | pkt.data= audio_out; | |
763 | pkt.size= ret; | |
e7902f20 | 764 | if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) |
c0df9d75 | 765 | pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); |
e928649b | 766 | pkt.flags |= PKT_FLAG_KEY; |
748c2fca | 767 | write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); |
85f07f22 FB |
768 | } |
769 | } | |
770 | ||
10d104e4 PG |
771 | static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp) |
772 | { | |
773 | AVCodecContext *dec; | |
774 | AVPicture *picture2; | |
775 | AVPicture picture_tmp; | |
0c1a9eda | 776 | uint8_t *buf = 0; |
10d104e4 | 777 | |
01f4895c | 778 | dec = ist->st->codec; |
10d104e4 PG |
779 | |
780 | /* deinterlace : must be done before any resize */ | |
fdf11906 | 781 | if (do_deinterlace) { |
10d104e4 PG |
782 | int size; |
783 | ||
784 | /* create temporary picture */ | |
785 | size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height); | |
786 | buf = av_malloc(size); | |
787 | if (!buf) | |
788 | return; | |
115329f1 | 789 | |
10d104e4 PG |
790 | picture2 = &picture_tmp; |
791 | avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height); | |
792 | ||
9e1cc598 RP |
793 | if(avpicture_deinterlace(picture2, picture, |
794 | dec->pix_fmt, dec->width, dec->height) < 0) { | |
795 | /* if error, do not deinterlace */ | |
796 | fprintf(stderr, "Deinterlacing failed\n"); | |
797 | av_free(buf); | |
798 | buf = NULL; | |
799 | picture2 = picture; | |
800 | } | |
10d104e4 PG |
801 | } else { |
802 | picture2 = picture; | |
803 | } | |
804 | ||
10d104e4 PG |
805 | if (picture != picture2) |
806 | *picture = *picture2; | |
807 | *bufp = buf; | |
808 | } | |
809 | ||
ec5517d5 FB |
810 | /* we begin to correct av delay at this threshold */ |
811 | #define AV_DELAY_MAX 0.100 | |
85f07f22 | 812 | |
115329f1 DB |
813 | static void do_subtitle_out(AVFormatContext *s, |
814 | AVOutputStream *ost, | |
cf7fc795 FB |
815 | AVInputStream *ist, |
816 | AVSubtitle *sub, | |
817 | int64_t pts) | |
818 | { | |
819 | static uint8_t *subtitle_out = NULL; | |
7f4fca03 | 820 | int subtitle_out_max_size = 1024 * 1024; |
cf7fc795 FB |
821 | int subtitle_out_size, nb, i; |
822 | AVCodecContext *enc; | |
823 | AVPacket pkt; | |
824 | ||
825 | if (pts == AV_NOPTS_VALUE) { | |
826 | fprintf(stderr, "Subtitle packets must have a pts\n"); | |
f2abc559 BC |
827 | if (exit_on_error) |
828 | av_exit(1); | |
cf7fc795 FB |
829 | return; |
830 | } | |
831 | ||
01f4895c | 832 | enc = ost->st->codec; |
cf7fc795 FB |
833 | |
834 | if (!subtitle_out) { | |
835 | subtitle_out = av_malloc(subtitle_out_max_size); | |
836 | } | |
837 | ||
838 | /* Note: DVB subtitle need one packet to draw them and one other | |
839 | packet to clear them */ | |
840 | /* XXX: signal it in the codec context ? */ | |
841 | if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) | |
842 | nb = 2; | |
843 | else | |
844 | nb = 1; | |
845 | ||
846 | for(i = 0; i < nb; i++) { | |
4bbe788a | 847 | sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q); |
8b03c014 RD |
848 | // start_display_time is required to be 0 |
849 | sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q); | |
850 | sub->end_display_time -= sub->start_display_time; | |
851 | sub->start_display_time = 0; | |
115329f1 | 852 | subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out, |
cf7fc795 | 853 | subtitle_out_max_size, sub); |
266649a5 RD |
854 | if (subtitle_out_size < 0) { |
855 | fprintf(stderr, "Subtitle encoding failed\n"); | |
856 | av_exit(1); | |
857 | } | |
115329f1 | 858 | |
cf7fc795 FB |
859 | av_init_packet(&pkt); |
860 | pkt.stream_index = ost->index; | |
861 | pkt.data = subtitle_out; | |
862 | pkt.size = subtitle_out_size; | |
8b03c014 | 863 | pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base); |
cf7fc795 FB |
864 | if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) { |
865 | /* XXX: the pts correction is handled here. Maybe handling | |
866 | it in the codec would be better */ | |
867 | if (i == 0) | |
868 | pkt.pts += 90 * sub->start_display_time; | |
869 | else | |
870 | pkt.pts += 90 * sub->end_display_time; | |
871 | } | |
748c2fca | 872 | write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); |
cf7fc795 FB |
873 | } |
874 | } | |
875 | ||
8a6cb114 | 876 | static int bit_buffer_size= 1024*256; |
27537106 | 877 | static uint8_t *bit_buffer= NULL; |
1ff93ffc | 878 | |
115329f1 DB |
879 | static void do_video_out(AVFormatContext *s, |
880 | AVOutputStream *ost, | |
85f07f22 | 881 | AVInputStream *ist, |
7a0f9d7e | 882 | AVFrame *in_picture, |
986ebcdb | 883 | int *frame_size) |
85f07f22 | 884 | { |
ec5517d5 | 885 | int nb_frames, i, ret; |
352666c1 | 886 | int64_t topBand, bottomBand, leftBand, rightBand; |
07d0cdfc | 887 | AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src; |
18a54b04 | 888 | AVFrame picture_crop_temp, picture_pad_temp; |
cfcf0ffd | 889 | AVCodecContext *enc, *dec; |
115329f1 | 890 | |
a4d36c11 | 891 | avcodec_get_frame_defaults(&picture_crop_temp); |
07d0cdfc | 892 | avcodec_get_frame_defaults(&picture_pad_temp); |
a4d36c11 | 893 | |
01f4895c MN |
894 | enc = ost->st->codec; |
895 | dec = ist->st->codec; | |
85f07f22 | 896 | |
ec5517d5 FB |
897 | /* by default, we output a single frame */ |
898 | nb_frames = 1; | |
899 | ||
204c0f48 PG |
900 | *frame_size = 0; |
901 | ||
9ff261a2 | 902 | if(video_sync_method){ |
10d104e4 | 903 | double vdelta; |
b4a3389e | 904 | vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts; |
e928649b MN |
905 | //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c |
906 | if (vdelta < -1.1) | |
907 | nb_frames = 0; | |
e6fdc2b1 MN |
908 | else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){ |
909 | if(vdelta<=-0.6){ | |
910 | nb_frames=0; | |
911 | }else if(vdelta>0.6) | |
880add37 | 912 | ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base)); |
e6fdc2b1 | 913 | }else if (vdelta > 1.1) |
70122f29 | 914 | nb_frames = lrintf(vdelta); |
fc6765d7 | 915 | //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); |
50c3dd32 MN |
916 | if (nb_frames == 0){ |
917 | ++nb_frames_drop; | |
918 | if (verbose>2) | |
919 | fprintf(stderr, "*** drop!\n"); | |
8300609b | 920 | }else if (nb_frames > 1) { |
ed30e518 | 921 | nb_frames_dup += nb_frames - 1; |
50c3dd32 | 922 | if (verbose>2) |
8300609b | 923 | fprintf(stderr, "*** %d dup!\n", nb_frames-1); |
50c3dd32 MN |
924 | } |
925 | }else | |
b4a3389e | 926 | ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base)); |
445f1b83 | 927 | |
7ca60994 | 928 | nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number); |
115329f1 | 929 | if (nb_frames <= 0) |
85f07f22 | 930 | return; |
ce7c56c2 | 931 | |
07d0cdfc | 932 | if (ost->video_crop) { |
636d6a4a | 933 | if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) { |
49a06a4d | 934 | fprintf(stderr, "error cropping picture\n"); |
f2abc559 BC |
935 | if (exit_on_error) |
936 | av_exit(1); | |
4e780252 | 937 | return; |
07d0cdfc LA |
938 | } |
939 | formatted_picture = &picture_crop_temp; | |
18a54b04 LA |
940 | } else { |
941 | formatted_picture = in_picture; | |
07d0cdfc LA |
942 | } |
943 | ||
944 | final_picture = formatted_picture; | |
945 | padding_src = formatted_picture; | |
946 | resampling_dst = &ost->pict_tmp; | |
947 | if (ost->video_pad) { | |
948 | final_picture = &ost->pict_tmp; | |
949 | if (ost->video_resample) { | |
636d6a4a | 950 | if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) { |
49a06a4d | 951 | fprintf(stderr, "error padding picture\n"); |
f2abc559 BC |
952 | if (exit_on_error) |
953 | av_exit(1); | |
4e780252 | 954 | return; |
07d0cdfc LA |
955 | } |
956 | resampling_dst = &picture_pad_temp; | |
957 | } | |
958 | } | |
959 | ||
b83ccbff MN |
960 | if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand))) |
961 | || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand))) | |
962 | || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) { | |
963 | ||
964 | fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt)); | |
965 | if(!ost->video_resample) | |
966 | av_exit(1); | |
967 | } | |
968 | ||
85f07f22 | 969 | if (ost->video_resample) { |
07d0cdfc | 970 | padding_src = NULL; |
34b10a57 | 971 | final_picture = &ost->pict_tmp; |
352666c1 | 972 | if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand))) |
01a3c821 JGG |
973 | || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand))) |
974 | || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) { | |
352666c1 | 975 | |
352666c1 EB |
976 | /* keep bands proportional to the frame size */ |
977 | topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1; | |
978 | bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1; | |
979 | leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1; | |
980 | rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1; | |
981 | ||
982 | /* sanity check to ensure no bad band sizes sneak in */ | |
983 | assert(topBand <= INT_MAX && topBand >= 0); | |
984 | assert(bottomBand <= INT_MAX && bottomBand >= 0); | |
985 | assert(leftBand <= INT_MAX && leftBand >= 0); | |
986 | assert(rightBand <= INT_MAX && rightBand >= 0); | |
987 | ||
988 | ost->topBand = topBand; | |
989 | ost->bottomBand = bottomBand; | |
990 | ost->leftBand = leftBand; | |
991 | ost->rightBand = rightBand; | |
992 | ||
993 | ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand); | |
994 | ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand); | |
01a3c821 | 995 | ost->resample_pix_fmt= ist->st->codec->pix_fmt; |
352666c1 EB |
996 | |
997 | /* initialize a new scaler context */ | |
998 | sws_freeContext(ost->img_resample_ctx); | |
999 | sws_flags = av_get_int(sws_opts, "sws_flags", NULL); | |
1000 | ost->img_resample_ctx = sws_getContext( | |
1001 | ist->st->codec->width - (ost->leftBand + ost->rightBand), | |
1002 | ist->st->codec->height - (ost->topBand + ost->bottomBand), | |
1003 | ist->st->codec->pix_fmt, | |
1004 | ost->st->codec->width - (ost->padleft + ost->padright), | |
1005 | ost->st->codec->height - (ost->padtop + ost->padbottom), | |
1006 | ost->st->codec->pix_fmt, | |
1007 | sws_flags, NULL, NULL, NULL); | |
1008 | if (ost->img_resample_ctx == NULL) { | |
1009 | fprintf(stderr, "Cannot get resampling context\n"); | |
1010 | av_exit(1); | |
1011 | } | |
1012 | } | |
18a54b04 LA |
1013 | sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize, |
1014 | 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize); | |
f122deb4 | 1015 | } |
07d0cdfc LA |
1016 | |
1017 | if (ost->video_pad) { | |
636d6a4a | 1018 | av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src, |
07d0cdfc LA |
1019 | enc->height, enc->width, enc->pix_fmt, |
1020 | ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor); | |
85f07f22 | 1021 | } |
07d0cdfc | 1022 | |
85f07f22 | 1023 | /* duplicates frame if needed */ |
ec5517d5 | 1024 | for(i=0;i<nb_frames;i++) { |
e928649b MN |
1025 | AVPacket pkt; |
1026 | av_init_packet(&pkt); | |
1027 | pkt.stream_index= ost->index; | |
1028 | ||
e8750b00 FR |
1029 | if (s->oformat->flags & AVFMT_RAWPICTURE) { |
1030 | /* raw pictures are written as AVPicture structure to | |
1031 | avoid any copies. We support temorarily the older | |
1032 | method. */ | |
2744ca9a | 1033 | AVFrame* old_frame = enc->coded_frame; |
bb270c08 | 1034 | enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack |
e928649b MN |
1035 | pkt.data= (uint8_t *)final_picture; |
1036 | pkt.size= sizeof(AVPicture); | |
b4dba580 MN |
1037 | pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base); |
1038 | pkt.flags |= PKT_FLAG_KEY; | |
e928649b | 1039 | |
748c2fca | 1040 | write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); |
bb270c08 | 1041 | enc->coded_frame = old_frame; |
e8750b00 | 1042 | } else { |
492cd3a9 | 1043 | AVFrame big_picture; |
a4d36c11 MN |
1044 | |
1045 | big_picture= *final_picture; | |
7a0f9d7e FB |
1046 | /* better than nothing: use input picture interlaced |
1047 | settings */ | |
1048 | big_picture.interlaced_frame = in_picture->interlaced_frame; | |
636f1c4c | 1049 | if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){ |
bb198e19 MN |
1050 | if(top_field_first == -1) |
1051 | big_picture.top_field_first = in_picture->top_field_first; | |
1052 | else | |
2a8edc5d | 1053 | big_picture.top_field_first = top_field_first; |
bb198e19 | 1054 | } |
7a0f9d7e | 1055 | |
85f07f22 FB |
1056 | /* handles sameq here. This is not correct because it may |
1057 | not be a global option */ | |
1058 | if (same_quality) { | |
1e491e29 MN |
1059 | big_picture.quality = ist->st->quality; |
1060 | }else | |
1061 | big_picture.quality = ost->st->quality; | |
f4f3223f MN |
1062 | if(!me_threshold) |
1063 | big_picture.pict_type = 0; | |
50c3dd32 | 1064 | // big_picture.pts = AV_NOPTS_VALUE; |
c0df9d75 MN |
1065 | big_picture.pts= ost->sync_opts; |
1066 | // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den); | |
949b1a13 | 1067 | //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts); |
115329f1 | 1068 | ret = avcodec_encode_video(enc, |
8a6cb114 | 1069 | bit_buffer, bit_buffer_size, |
1e491e29 | 1070 | &big_picture); |
95af5e1c | 1071 | if (ret < 0) { |
4156a436 | 1072 | fprintf(stderr, "Video encoding failed\n"); |
296df4e7 | 1073 | av_exit(1); |
4156a436 | 1074 | } |
54e28a85 | 1075 | |
4bbc6260 | 1076 | if(ret>0){ |
27537106 | 1077 | pkt.data= bit_buffer; |
e928649b | 1078 | pkt.size= ret; |
e6b4e4ff | 1079 | if(enc->coded_frame->pts != AV_NOPTS_VALUE) |
c0df9d75 | 1080 | pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); |
949b1a13 | 1081 | /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n", |
c0df9d75 MN |
1082 | pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1, |
1083 | pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/ | |
50c3dd32 | 1084 | |
e6b4e4ff | 1085 | if(enc->coded_frame->key_frame) |
e928649b | 1086 | pkt.flags |= PKT_FLAG_KEY; |
748c2fca | 1087 | write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); |
e928649b | 1088 | *frame_size = ret; |
44eb047a | 1089 | video_size += ret; |
54e28a85 BC |
1090 | //fprintf(stderr,"\nFrame: %3d size: %5d type: %d", |
1091 | // enc->frame_number-1, ret, enc->pict_type); | |
e928649b MN |
1092 | /* if two pass, output log */ |
1093 | if (ost->logfile && enc->stats_out) { | |
1094 | fprintf(ost->logfile, "%s", enc->stats_out); | |
1095 | } | |
5abdb4b1 | 1096 | } |
85f07f22 | 1097 | } |
50c3dd32 | 1098 | ost->sync_opts++; |
ec5517d5 | 1099 | ost->frame_number++; |
85f07f22 FB |
1100 | } |
1101 | } | |
1102 | ||
140cb663 | 1103 | static double psnr(double d){ |
b29f97d1 | 1104 | return -10.0*log(d)/log(10.0); |
140cb663 MN |
1105 | } |
1106 | ||
115329f1 | 1107 | static void do_video_stats(AVFormatContext *os, AVOutputStream *ost, |
ec5517d5 | 1108 | int frame_size) |
ce7c56c2 | 1109 | { |
ce7c56c2 J |
1110 | AVCodecContext *enc; |
1111 | int frame_number; | |
ce7c56c2 | 1112 | double ti1, bitrate, avg_bitrate; |
115329f1 | 1113 | |
b60d1379 | 1114 | /* this is executed just the first time do_video_stats is called */ |
032aa7df SS |
1115 | if (!vstats_file) { |
1116 | vstats_file = fopen(vstats_filename, "w"); | |
1117 | if (!vstats_file) { | |
4bd0c2b1 | 1118 | perror("fopen"); |
296df4e7 | 1119 | av_exit(1); |
4bd0c2b1 BF |
1120 | } |
1121 | } | |
1122 | ||
01f4895c | 1123 | enc = ost->st->codec; |
ce7c56c2 | 1124 | if (enc->codec_type == CODEC_TYPE_VIDEO) { |
ec5517d5 | 1125 | frame_number = ost->frame_number; |
032aa7df | 1126 | fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA); |
140cb663 | 1127 | if (enc->flags&CODEC_FLAG_PSNR) |
032aa7df | 1128 | fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0))); |
115329f1 | 1129 | |
032aa7df | 1130 | fprintf(vstats_file,"f_size= %6d ", frame_size); |
ec5517d5 | 1131 | /* compute pts value */ |
c0df9d75 | 1132 | ti1 = ost->sync_opts * av_q2d(enc->time_base); |
ce7c56c2 J |
1133 | if (ti1 < 0.01) |
1134 | ti1 = 0.01; | |
115329f1 | 1135 | |
c0df9d75 | 1136 | bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0; |
1008ceb3 | 1137 | avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0; |
032aa7df | 1138 | fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ", |
1008ceb3 | 1139 | (double)video_size / 1024, ti1, bitrate, avg_bitrate); |
032aa7df | 1140 | fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type)); |
ce7c56c2 | 1141 | } |
ec5517d5 FB |
1142 | } |
1143 | ||
b29f97d1 | 1144 | static void print_report(AVFormatContext **output_files, |
bb270c08 DB |
1145 | AVOutputStream **ost_table, int nb_ostreams, |
1146 | int is_last_report) | |
ec5517d5 FB |
1147 | { |
1148 | char buf[1024]; | |
1149 | AVOutputStream *ost; | |
b5ee9c23 | 1150 | AVFormatContext *oc; |
0c1a9eda | 1151 | int64_t total_size; |
ec5517d5 FB |
1152 | AVCodecContext *enc; |
1153 | int frame_number, vid, i; | |
1154 | double bitrate, ti1, pts; | |
0c1a9eda | 1155 | static int64_t last_time = -1; |
0888fd22 | 1156 | static int qp_histogram[52]; |
115329f1 | 1157 | |
ec5517d5 | 1158 | if (!is_last_report) { |
0c1a9eda | 1159 | int64_t cur_time; |
ec5517d5 FB |
1160 | /* display the report every 0.5 seconds */ |
1161 | cur_time = av_gettime(); | |
1162 | if (last_time == -1) { | |
1163 | last_time = cur_time; | |
1164 | return; | |
115329f1 | 1165 | } |
ec5517d5 FB |
1166 | if ((cur_time - last_time) < 500000) |
1167 | return; | |
1168 | last_time = cur_time; | |
1169 | } | |
1170 | ||
ce7c56c2 | 1171 | |
ec5517d5 FB |
1172 | oc = output_files[0]; |
1173 | ||
899681cd | 1174 | total_size = url_fsize(oc->pb); |
859d95ba | 1175 | if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too |
899681cd | 1176 | total_size= url_ftell(oc->pb); |
115329f1 | 1177 | |
ec5517d5 FB |
1178 | buf[0] = '\0'; |
1179 | ti1 = 1e10; | |
1180 | vid = 0; | |
1181 | for(i=0;i<nb_ostreams;i++) { | |
1182 | ost = ost_table[i]; | |
01f4895c | 1183 | enc = ost->st->codec; |
10d104e4 | 1184 | if (vid && enc->codec_type == CODEC_TYPE_VIDEO) { |
0ecca7a4 | 1185 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", |
e6b4e4ff | 1186 | !ost->st->stream_copy ? |
99fb79b5 | 1187 | enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1); |
10d104e4 | 1188 | } |
ec5517d5 | 1189 | if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) { |
7fc98937 LW |
1190 | float t = (av_gettime()-timer_start) / 1000000.0; |
1191 | ||
ec5517d5 | 1192 | frame_number = ost->frame_number; |
7fc98937 LW |
1193 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ", |
1194 | frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, | |
e6b4e4ff | 1195 | !ost->st->stream_copy ? |
99fb79b5 | 1196 | enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1); |
890972be | 1197 | if(is_last_report) |
0ecca7a4 | 1198 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L"); |
e6b4e4ff | 1199 | if(qp_hist){ |
0888fd22 MN |
1200 | int j; |
1201 | int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA); | |
37d3e066 | 1202 | if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram)) |
0888fd22 MN |
1203 | qp_histogram[qp]++; |
1204 | for(j=0; j<32; j++) | |
1205 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2))); | |
1206 | } | |
890972be MN |
1207 | if (enc->flags&CODEC_FLAG_PSNR){ |
1208 | int j; | |
1209 | double error, error_sum=0; | |
1210 | double scale, scale_sum=0; | |
1211 | char type[3]= {'Y','U','V'}; | |
0ecca7a4 | 1212 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR="); |
890972be MN |
1213 | for(j=0; j<3; j++){ |
1214 | if(is_last_report){ | |
1215 | error= enc->error[j]; | |
1216 | scale= enc->width*enc->height*255.0*255.0*frame_number; | |
1217 | }else{ | |
1218 | error= enc->coded_frame->error[j]; | |
1219 | scale= enc->width*enc->height*255.0*255.0; | |
1220 | } | |
1221 | if(j) scale/=4; | |
1222 | error_sum += error; | |
1223 | scale_sum += scale; | |
0ecca7a4 | 1224 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale)); |
890972be | 1225 | } |
0ecca7a4 | 1226 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum)); |
890972be | 1227 | } |
ec5517d5 FB |
1228 | vid = 1; |
1229 | } | |
1230 | /* compute min output value */ | |
43924f01 | 1231 | pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base); |
5d9827bc | 1232 | if ((pts < ti1) && (pts > 0)) |
ec5517d5 FB |
1233 | ti1 = pts; |
1234 | } | |
1235 | if (ti1 < 0.01) | |
1236 | ti1 = 0.01; | |
115329f1 | 1237 | |
f068206e BE |
1238 | if (verbose || is_last_report) { |
1239 | bitrate = (double)(total_size * 8) / ti1 / 1000.0; | |
115329f1 DB |
1240 | |
1241 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), | |
475f4d8d | 1242 | "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s", |
ec5517d5 | 1243 | (double)total_size / 1024, ti1, bitrate); |
a6a92a9a | 1244 | |
0f649d66 | 1245 | if (nb_frames_dup || nb_frames_drop) |
bb270c08 DB |
1246 | snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d", |
1247 | nb_frames_dup, nb_frames_drop); | |
115329f1 | 1248 | |
d8019eb5 AD |
1249 | if (verbose >= 0) |
1250 | fprintf(stderr, "%s \r", buf); | |
1251 | ||
ec5517d5 FB |
1252 | fflush(stderr); |
1253 | } | |
115329f1 | 1254 | |
1008ceb3 MN |
1255 | if (is_last_report && verbose >= 0){ |
1256 | int64_t raw= audio_size + video_size + extra_size; | |
f068206e | 1257 | fprintf(stderr, "\n"); |
1008ceb3 MN |
1258 | fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n", |
1259 | video_size/1024.0, | |
1260 | audio_size/1024.0, | |
1261 | extra_size/1024.0, | |
1262 | 100.0*(total_size - raw)/raw | |
1263 | ); | |
1264 | } | |
ce7c56c2 J |
1265 | } |
1266 | ||
a700a6ae FB |
1267 | /* pkt = NULL means EOF (needed to flush decoder buffers) */ |
1268 | static int output_packet(AVInputStream *ist, int ist_index, | |
1269 | AVOutputStream **ost_table, int nb_ostreams, | |
4b85a28f | 1270 | const AVPacket *pkt) |
a700a6ae FB |
1271 | { |
1272 | AVFormatContext *os; | |
1273 | AVOutputStream *ost; | |
ede0e475 | 1274 | int ret, i; |
a700a6ae FB |
1275 | uint8_t *data_buf; |
1276 | int data_size, got_picture; | |
1277 | AVFrame picture; | |
a700a6ae | 1278 | void *buffer_to_free; |
f038fe8b | 1279 | static unsigned int samples_size= 0; |
cf7fc795 FB |
1280 | AVSubtitle subtitle, *subtitle_to_free; |
1281 | int got_subtitle; | |
ede0e475 | 1282 | AVPacket avpkt; |
9d66ef18 | 1283 | int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3; |
ede0e475 | 1284 | |
ed923859 MN |
1285 | if(ist->next_pts == AV_NOPTS_VALUE) |
1286 | ist->next_pts= ist->pts; | |
1287 | ||
a700a6ae FB |
1288 | if (pkt == NULL) { |
1289 | /* EOF handling */ | |
031e14ea | 1290 | av_init_packet(&avpkt); |
ede0e475 TB |
1291 | avpkt.data = NULL; |
1292 | avpkt.size = 0; | |
a700a6ae | 1293 | goto handle_eof; |
031e14ea TB |
1294 | } else { |
1295 | avpkt = *pkt; | |
a700a6ae FB |
1296 | } |
1297 | ||
b1b818fc MN |
1298 | if(pkt->dts != AV_NOPTS_VALUE) |
1299 | ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q); | |
1300 | ||
bd6754aa | 1301 | //while we have more to decode or while the decoder did output something on EOF |
ede0e475 | 1302 | while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) { |
a700a6ae | 1303 | handle_eof: |
b1b818fc | 1304 | ist->pts= ist->next_pts; |
19d5da50 | 1305 | |
d859bb1d SS |
1306 | if(avpkt.size && avpkt.size != pkt->size && |
1307 | !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0) | |
40cb57a2 MN |
1308 | fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index); |
1309 | ||
a700a6ae FB |
1310 | /* decode the packet if needed */ |
1311 | data_buf = NULL; /* fail safe */ | |
1312 | data_size = 0; | |
cf7fc795 | 1313 | subtitle_to_free = NULL; |
a700a6ae | 1314 | if (ist->decoding_needed) { |
01f4895c | 1315 | switch(ist->st->codec->codec_type) { |
df84ac2e | 1316 | case CODEC_TYPE_AUDIO:{ |
81b060fa LM |
1317 | if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) { |
1318 | samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE); | |
1319 | av_free(samples); | |
1320 | samples= av_malloc(samples_size); | |
1321 | } | |
5d55e966 | 1322 | data_size= samples_size; |
a700a6ae FB |
1323 | /* XXX: could avoid copy if PCM 16 bits with same |
1324 | endianness as CPU */ | |
ede0e475 TB |
1325 | ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size, |
1326 | &avpkt); | |
a700a6ae FB |
1327 | if (ret < 0) |
1328 | goto fail_decode; | |
ede0e475 TB |
1329 | avpkt.data += ret; |
1330 | avpkt.size -= ret; | |
a700a6ae FB |
1331 | /* Some bug in mpeg audio decoder gives */ |
1332 | /* data_size < 0, it seems they are overflows */ | |
1333 | if (data_size <= 0) { | |
1334 | /* no audio frame */ | |
1335 | continue; | |
1336 | } | |
1337 | data_buf = (uint8_t *)samples; | |
9d66ef18 | 1338 | ist->next_pts += ((int64_t)AV_TIME_BASE/bps * data_size) / |
01f4895c | 1339 | (ist->st->codec->sample_rate * ist->st->codec->channels); |
df84ac2e | 1340 | break;} |
a700a6ae | 1341 | case CODEC_TYPE_VIDEO: |
01f4895c | 1342 | data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2; |
a700a6ae | 1343 | /* XXX: allocate picture correctly */ |
9740beff MN |
1344 | avcodec_get_frame_defaults(&picture); |
1345 | ||
ede0e475 TB |
1346 | ret = avcodec_decode_video2(ist->st->codec, |
1347 | &picture, &got_picture, &avpkt); | |
a700a6ae | 1348 | ist->st->quality= picture.quality; |
115329f1 | 1349 | if (ret < 0) |
a700a6ae FB |
1350 | goto fail_decode; |
1351 | if (!got_picture) { | |
1352 | /* no picture yet */ | |
1353 | goto discard_packet; | |
1354 | } | |
01f4895c | 1355 | if (ist->st->codec->time_base.num != 0) { |
3797c74b | 1356 | int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame; |
115329f1 | 1357 | ist->next_pts += ((int64_t)AV_TIME_BASE * |
34583e1b | 1358 | ist->st->codec->time_base.num * ticks) / |
01f4895c | 1359 | ist->st->codec->time_base.den; |
a700a6ae | 1360 | } |
ede0e475 | 1361 | avpkt.size = 0; |
a700a6ae | 1362 | break; |
cf7fc795 | 1363 | case CODEC_TYPE_SUBTITLE: |
ede0e475 TB |
1364 | ret = avcodec_decode_subtitle2(ist->st->codec, |
1365 | &subtitle, &got_subtitle, &avpkt); | |
cf7fc795 | 1366 | if (ret < 0) |
a700a6ae | 1367 | goto fail_decode; |
cf7fc795 FB |
1368 | if (!got_subtitle) { |
1369 | goto discard_packet; | |
a700a6ae | 1370 | } |
cf7fc795 | 1371 | subtitle_to_free = &subtitle; |
ede0e475 | 1372 | avpkt.size = 0; |
cf7fc795 FB |
1373 | break; |
1374 | default: | |
1375 | goto fail_decode; | |
1376 | } | |
1377 | } else { | |
bde0705c LW |
1378 | switch(ist->st->codec->codec_type) { |
1379 | case CODEC_TYPE_AUDIO: | |
1380 | ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) / | |
1c715415 | 1381 | ist->st->codec->sample_rate; |
bde0705c LW |
1382 | break; |
1383 | case CODEC_TYPE_VIDEO: | |
1384 | if (ist->st->codec->time_base.num != 0) { | |
3797c74b | 1385 | int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame; |
bde0705c | 1386 | ist->next_pts += ((int64_t)AV_TIME_BASE * |
34583e1b | 1387 | ist->st->codec->time_base.num * ticks) / |
bde0705c | 1388 | ist->st->codec->time_base.den; |
2fef0bdf | 1389 | } |
bde0705c | 1390 | break; |
a700a6ae | 1391 | } |
ede0e475 TB |
1392 | data_buf = avpkt.data; |
1393 | data_size = avpkt.size; | |
1394 | ret = avpkt.size; | |
1395 | avpkt.size = 0; | |
bde0705c | 1396 | } |
a700a6ae | 1397 | |
bde0705c LW |
1398 | buffer_to_free = NULL; |
1399 | if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) { | |
1400 | pre_process_video_frame(ist, (AVPicture *)&picture, | |
1401 | &buffer_to_free); | |
1402 | } | |
a700a6ae | 1403 | |
bde0705c LW |
1404 | // preprocess audio (volume) |
1405 | if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) { | |
1406 | if (audio_volume != 256) { | |
1407 | short *volp; | |
1408 | volp = samples; | |
1409 | for(i=0;i<(data_size / sizeof(short));i++) { | |
1410 | int v = ((*volp) * audio_volume + 128) >> 8; | |
1411 | if (v < -32768) v = -32768; | |
1412 | if (v > 32767) v = 32767; | |
1413 | *volp++ = v; | |
7e987c33 C |
1414 | } |
1415 | } | |
bde0705c | 1416 | } |
7e987c33 | 1417 | |
bde0705c | 1418 | /* frame rate emulation */ |
3a25ca18 | 1419 | if (rate_emu) { |
cb103a19 | 1420 | int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE); |
bde0705c LW |
1421 | int64_t now = av_gettime() - ist->start; |
1422 | if (pts > now) | |
1423 | usleep(pts - now); | |
bde0705c | 1424 | } |
a700a6ae | 1425 | |
bde0705c LW |
1426 | /* if output time reached then transcode raw format, |
1427 | encode packets and output them */ | |
1428 | if (start_time == 0 || ist->pts >= start_time) | |
1429 | for(i=0;i<nb_ostreams;i++) { | |
1430 | int frame_size; | |
a700a6ae | 1431 | |
bde0705c LW |
1432 | ost = ost_table[i]; |
1433 | if (ost->source_index == ist_index) { | |
1434 | os = output_files[ost->file_index]; | |
a700a6ae | 1435 | |
bde0705c LW |
1436 | /* set the input output pts pairs */ |
1437 | //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE; | |
1438 | ||
1439 | if (ost->encoding_needed) { | |
1440 | switch(ost->st->codec->codec_type) { | |
1441 | case CODEC_TYPE_AUDIO: | |
1442 | do_audio_out(os, ost, ist, data_buf, data_size); | |
1443 | break; | |
1444 | case CODEC_TYPE_VIDEO: | |
1445 | do_video_out(os, ost, ist, &picture, &frame_size); | |
b60d1379 | 1446 | if (vstats_filename && frame_size) |
bde0705c LW |
1447 | do_video_stats(os, ost, frame_size); |
1448 | break; | |
1449 | case CODEC_TYPE_SUBTITLE: | |
1450 | do_subtitle_out(os, ost, ist, &subtitle, | |
1451 | pkt->pts); | |
1452 | break; | |
1453 | default: | |
0f4e8165 | 1454 | abort(); |
bde0705c LW |
1455 | } |
1456 | } else { | |
1457 | AVFrame avframe; //FIXME/XXX remove this | |
1458 | AVPacket opkt; | |
cdf38a17 MN |
1459 | int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base); |
1460 | ||
bde0705c LW |
1461 | av_init_packet(&opkt); |
1462 | ||
50e3477f | 1463 | if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes) |
7cacf1e8 MN |
1464 | continue; |
1465 | ||
bde0705c LW |
1466 | /* no reencoding needed : output the packet directly */ |
1467 | /* force the input stream PTS */ | |
1468 | ||
1469 | avcodec_get_frame_defaults(&avframe); | |
1470 | ost->st->codec->coded_frame= &avframe; | |
1471 | avframe.key_frame = pkt->flags & PKT_FLAG_KEY; | |
1472 | ||
1473 | if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO) | |
1474 | audio_size += data_size; | |
1475 | else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) { | |
1476 | video_size += data_size; | |
1477 | ost->sync_opts++; | |
1478 | } | |
1479 | ||
1480 | opkt.stream_index= ost->index; | |
1481 | if(pkt->pts != AV_NOPTS_VALUE) | |
cdf38a17 | 1482 | opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time; |
bde0705c LW |
1483 | else |
1484 | opkt.pts= AV_NOPTS_VALUE; | |
1485 | ||
d2ce2f5e | 1486 | if (pkt->dts == AV_NOPTS_VALUE) |
181782ae | 1487 | opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base); |
d2ce2f5e BC |
1488 | else |
1489 | opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base); | |
cdf38a17 | 1490 | opkt.dts -= ost_tb_start_time; |
c0dd7b7c | 1491 | |
a03d59b7 | 1492 | opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base); |
bde0705c LW |
1493 | opkt.flags= pkt->flags; |
1494 | ||
1495 | //FIXME remove the following 2 lines they shall be replaced by the bitstream filters | |
d310d56a | 1496 | if(ost->st->codec->codec_id != CODEC_ID_H264) { |
bde0705c LW |
1497 | if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY)) |
1498 | opkt.destruct= av_destruct_packet; | |
d310d56a BC |
1499 | } else { |
1500 | opkt.data = data_buf; | |
1501 | opkt.size = data_size; | |
1502 | } | |
bde0705c | 1503 | |
8b389f15 | 1504 | write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]); |
bde0705c LW |
1505 | ost->st->codec->frame_number++; |
1506 | ost->frame_number++; | |
1507 | av_free_packet(&opkt); | |
a700a6ae FB |
1508 | } |
1509 | } | |
bde0705c LW |
1510 | } |
1511 | av_free(buffer_to_free); | |
1512 | /* XXX: allocate the subtitles in the codec ? */ | |
1513 | if (subtitle_to_free) { | |
1514 | if (subtitle_to_free->rects != NULL) { | |
1515 | for (i = 0; i < subtitle_to_free->num_rects; i++) { | |
25b4c651 MN |
1516 | av_freep(&subtitle_to_free->rects[i]->pict.data[0]); |
1517 | av_freep(&subtitle_to_free->rects[i]->pict.data[1]); | |
db4fac64 | 1518 | av_freep(&subtitle_to_free->rects[i]); |
c6ec28b1 | 1519 | } |
bde0705c | 1520 | av_freep(&subtitle_to_free->rects); |
cf7fc795 | 1521 | } |
bde0705c LW |
1522 | subtitle_to_free->num_rects = 0; |
1523 | subtitle_to_free = NULL; | |
a700a6ae | 1524 | } |
bde0705c | 1525 | } |
a700a6ae | 1526 | discard_packet: |
6f824977 MN |
1527 | if (pkt == NULL) { |
1528 | /* EOF handling */ | |
115329f1 | 1529 | |
6f824977 MN |
1530 | for(i=0;i<nb_ostreams;i++) { |
1531 | ost = ost_table[i]; | |
1532 | if (ost->source_index == ist_index) { | |
01f4895c | 1533 | AVCodecContext *enc= ost->st->codec; |
6f824977 | 1534 | os = output_files[ost->file_index]; |
115329f1 | 1535 | |
01f4895c | 1536 | if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1) |
6f824977 | 1537 | continue; |
01f4895c | 1538 | if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE)) |
6f824977 MN |
1539 | continue; |
1540 | ||
1541 | if (ost->encoding_needed) { | |
1542 | for(;;) { | |
1543 | AVPacket pkt; | |
cef7cc72 | 1544 | int fifo_bytes; |
6f824977 MN |
1545 | av_init_packet(&pkt); |
1546 | pkt.stream_index= ost->index; | |
115329f1 | 1547 | |
01f4895c | 1548 | switch(ost->st->codec->codec_type) { |
115329f1 | 1549 | case CODEC_TYPE_AUDIO: |
41dd680d | 1550 | fifo_bytes = av_fifo_size(ost->fifo); |
cef7cc72 JR |
1551 | ret = 0; |
1552 | /* encode any samples remaining in fifo */ | |
b10d7e4e | 1553 | if (fifo_bytes > 0) { |
22c4c3e0 | 1554 | int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3; |
cef7cc72 | 1555 | int fs_tmp = enc->frame_size; |
b10d7e4e | 1556 | |
3898eed8 | 1557 | av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL); |
b10d7e4e BC |
1558 | if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) { |
1559 | enc->frame_size = fifo_bytes / (osize * enc->channels); | |
1560 | } else { /* pad */ | |
1561 | int frame_bytes = enc->frame_size*osize*enc->channels; | |
1562 | if (samples_size < frame_bytes) | |
1563 | av_exit(1); | |
1564 | memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes); | |
1565 | } | |
1566 | ||
c573eb85 | 1567 | ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples); |
7c8689ef BC |
1568 | pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den, |
1569 | ost->st->time_base.num, enc->sample_rate); | |
cef7cc72 | 1570 | enc->frame_size = fs_tmp; |
9e0db7d5 MN |
1571 | } |
1572 | if(ret <= 0) { | |
cef7cc72 JR |
1573 | ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL); |
1574 | } | |
528271ff MN |
1575 | if (ret < 0) { |
1576 | fprintf(stderr, "Audio encoding failed\n"); | |
1577 | av_exit(1); | |
1578 | } | |
6f824977 MN |
1579 | audio_size += ret; |
1580 | pkt.flags |= PKT_FLAG_KEY; | |
1581 | break; | |
1582 | case CODEC_TYPE_VIDEO: | |
8a6cb114 | 1583 | ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL); |
528271ff MN |
1584 | if (ret < 0) { |
1585 | fprintf(stderr, "Video encoding failed\n"); | |
1586 | av_exit(1); | |
1587 | } | |
6f824977 MN |
1588 | video_size += ret; |
1589 | if(enc->coded_frame && enc->coded_frame->key_frame) | |
1590 | pkt.flags |= PKT_FLAG_KEY; | |
1591 | if (ost->logfile && enc->stats_out) { | |
1592 | fprintf(ost->logfile, "%s", enc->stats_out); | |
1593 | } | |
1594 | break; | |
1595 | default: | |
1596 | ret=-1; | |
1597 | } | |
115329f1 | 1598 | |
6f824977 MN |
1599 | if(ret<=0) |
1600 | break; | |
27537106 | 1601 | pkt.data= bit_buffer; |
6f824977 | 1602 | pkt.size= ret; |
e7902f20 | 1603 | if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) |
c0df9d75 | 1604 | pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); |
748c2fca | 1605 | write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); |
6f824977 MN |
1606 | } |
1607 | } | |
1608 | } | |
1609 | } | |
1610 | } | |
115329f1 | 1611 | |
a700a6ae FB |
1612 | return 0; |
1613 | fail_decode: | |
1614 | return -1; | |
1615 | } | |
1616 | ||
6d1ba1ac LA |
1617 | static void print_sdp(AVFormatContext **avc, int n) |
1618 | { | |
1619 | char sdp[2048]; | |
1620 | ||
1621 | avf_sdp_create(avc, n, sdp, sizeof(sdp)); | |
1622 | printf("SDP:\n%s\n", sdp); | |
536cd1db | 1623 | fflush(stdout); |
6d1ba1ac | 1624 | } |
a700a6ae | 1625 | |
50e143c4 NS |
1626 | static int stream_index_from_inputs(AVFormatContext **input_files, |
1627 | int nb_input_files, | |
1628 | AVInputFile *file_table, | |
1629 | AVInputStream **ist_table, | |
1630 | enum CodecType type, | |
1631 | int programid) | |
1632 | { | |
c1a4cdf9 | 1633 | int p, q, z; |
50e143c4 NS |
1634 | for(z=0; z<nb_input_files; z++) { |
1635 | AVFormatContext *ic = input_files[z]; | |
1636 | for(p=0; p<ic->nb_programs; p++) { | |
1637 | AVProgram *program = ic->programs[p]; | |
1638 | if(program->id != programid) | |
1639 | continue; | |
1640 | for(q=0; q<program->nb_stream_indexes; q++) { | |
1641 | int sidx = program->stream_index[q]; | |
1642 | int ris = file_table[z].ist_index + sidx; | |
1643 | if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type) | |
1644 | return ris; | |
1645 | } | |
1646 | } | |
1647 | } | |
1648 | ||
1649 | return -1; | |
1650 | } | |
1651 | ||
85f07f22 FB |
1652 | /* |
1653 | * The following code is the main loop of the file converter | |
1654 | */ | |
1655 | static int av_encode(AVFormatContext **output_files, | |
1656 | int nb_output_files, | |
1657 | AVFormatContext **input_files, | |
1658 | int nb_input_files, | |
1659 | AVStreamMap *stream_maps, int nb_stream_maps) | |
1660 | { | |
002c95d7 | 1661 | int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0; |
85f07f22 FB |
1662 | AVFormatContext *is, *os; |
1663 | AVCodecContext *codec, *icodec; | |
1664 | AVOutputStream *ost, **ost_table = NULL; | |
1665 | AVInputStream *ist, **ist_table = NULL; | |
bdc4796f | 1666 | AVInputFile *file_table; |
002c95d7 | 1667 | char error[1024]; |
cb09b2ed | 1668 | int key; |
6d1ba1ac | 1669 | int want_sdp = 1; |
545465ec MN |
1670 | uint8_t no_packet[MAX_FILES]={0}; |
1671 | int no_packet_count=0; | |
bdc4796f | 1672 | |
90901860 | 1673 | file_table= av_mallocz(nb_input_files * sizeof(AVInputFile)); |
bdc4796f FB |
1674 | if (!file_table) |
1675 | goto fail; | |
115329f1 | 1676 | |
85f07f22 FB |
1677 | /* input stream init */ |
1678 | j = 0; | |
1679 | for(i=0;i<nb_input_files;i++) { | |
1680 | is = input_files[i]; | |
1681 | file_table[i].ist_index = j; | |
79fdaa4c | 1682 | file_table[i].nb_streams = is->nb_streams; |
85f07f22 FB |
1683 | j += is->nb_streams; |
1684 | } | |
1685 | nb_istreams = j; | |
1686 | ||
1687 | ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *)); | |
1688 | if (!ist_table) | |
bdc4796f | 1689 | goto fail; |
115329f1 | 1690 | |
85f07f22 FB |
1691 | for(i=0;i<nb_istreams;i++) { |
1692 | ist = av_mallocz(sizeof(AVInputStream)); | |
1693 | if (!ist) | |
1694 | goto fail; | |
1695 | ist_table[i] = ist; | |
1696 | } | |
1697 | j = 0; | |
1698 | for(i=0;i<nb_input_files;i++) { | |
1699 | is = input_files[i]; | |
1700 | for(k=0;k<is->nb_streams;k++) { | |
1701 | ist = ist_table[j++]; | |
1702 | ist->st = is->streams[k]; | |
1703 | ist->file_index = i; | |
1704 | ist->index = k; | |
1705 | ist->discard = 1; /* the stream is discarded by default | |
1706 | (changed later) */ | |
bdfcbbed | 1707 | |
3a25ca18 | 1708 | if (rate_emu) { |
bdfcbbed | 1709 | ist->start = av_gettime(); |
bdfcbbed | 1710 | } |
85f07f22 FB |
1711 | } |
1712 | } | |
1713 | ||
1714 | /* output stream init */ | |
1715 | nb_ostreams = 0; | |
1716 | for(i=0;i<nb_output_files;i++) { | |
1717 | os = output_files[i]; | |
8a7bde1c | 1718 | if (!os->nb_streams) { |
fc5d0db5 SS |
1719 | dump_format(output_files[i], i, output_files[i]->filename, 1); |
1720 | fprintf(stderr, "Output file #%d does not contain any stream\n", i); | |
296df4e7 | 1721 | av_exit(1); |
8a7bde1c | 1722 | } |
85f07f22 FB |
1723 | nb_ostreams += os->nb_streams; |
1724 | } | |
1725 | if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) { | |
1726 | fprintf(stderr, "Number of stream maps must match number of output streams\n"); | |
296df4e7 | 1727 | av_exit(1); |
85f07f22 FB |
1728 | } |
1729 | ||
bd073980 BF |
1730 | /* Sanity check the mapping args -- do the input files & streams exist? */ |
1731 | for(i=0;i<nb_stream_maps;i++) { | |
1732 | int fi = stream_maps[i].file_index; | |
1733 | int si = stream_maps[i].stream_index; | |
115329f1 | 1734 | |
bd073980 BF |
1735 | if (fi < 0 || fi > nb_input_files - 1 || |
1736 | si < 0 || si > file_table[fi].nb_streams - 1) { | |
1737 | fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si); | |
296df4e7 | 1738 | av_exit(1); |
bd073980 | 1739 | } |
b4a3389e WG |
1740 | fi = stream_maps[i].sync_file_index; |
1741 | si = stream_maps[i].sync_stream_index; | |
1742 | if (fi < 0 || fi > nb_input_files - 1 || | |
1743 | si < 0 || si > file_table[fi].nb_streams - 1) { | |
1744 | fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si); | |
296df4e7 | 1745 | av_exit(1); |
b4a3389e | 1746 | } |
bd073980 | 1747 | } |
115329f1 | 1748 | |
85f07f22 FB |
1749 | ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams); |
1750 | if (!ost_table) | |
1751 | goto fail; | |
1752 | for(i=0;i<nb_ostreams;i++) { | |
1753 | ost = av_mallocz(sizeof(AVOutputStream)); | |
1754 | if (!ost) | |
1755 | goto fail; | |
1756 | ost_table[i] = ost; | |
1757 | } | |
115329f1 | 1758 | |
85f07f22 FB |
1759 | n = 0; |
1760 | for(k=0;k<nb_output_files;k++) { | |
1761 | os = output_files[k]; | |
de427ff4 | 1762 | for(i=0;i<os->nb_streams;i++,n++) { |
85f07f22 | 1763 | int found; |
de427ff4 | 1764 | ost = ost_table[n]; |
85f07f22 FB |
1765 | ost->file_index = k; |
1766 | ost->index = i; | |
1767 | ost->st = os->streams[i]; | |
1768 | if (nb_stream_maps > 0) { | |
de427ff4 SS |
1769 | ost->source_index = file_table[stream_maps[n].file_index].ist_index + |
1770 | stream_maps[n].stream_index; | |
115329f1 | 1771 | |
bd073980 | 1772 | /* Sanity check that the stream types match */ |
01f4895c | 1773 | if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) { |
150d5a25 SS |
1774 | int i= ost->file_index; |
1775 | dump_format(output_files[i], i, output_files[i]->filename, 1); | |
bd073980 | 1776 | fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n", |
de427ff4 | 1777 | stream_maps[n].file_index, stream_maps[n].stream_index, |
bd073980 | 1778 | ost->file_index, ost->index); |
296df4e7 | 1779 | av_exit(1); |
bd073980 | 1780 | } |
115329f1 | 1781 | |
85f07f22 | 1782 | } else { |
50e143c4 NS |
1783 | if(opt_programid) { |
1784 | found = 0; | |
1785 | j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid); | |
1786 | if(j != -1) { | |
1787 | ost->source_index = j; | |
1788 | found = 1; | |
1789 | } | |
1790 | } else { | |
a15bc651 NS |
1791 | /* get corresponding input stream index : we select the first one with the right type */ |
1792 | found = 0; | |
85f07f22 FB |
1793 | for(j=0;j<nb_istreams;j++) { |
1794 | ist = ist_table[j]; | |
a15bc651 NS |
1795 | if (ist->discard && |
1796 | ist->st->codec->codec_type == ost->st->codec->codec_type) { | |
85f07f22 FB |
1797 | ost->source_index = j; |
1798 | found = 1; | |
a15bc651 | 1799 | break; |
85f07f22 FB |
1800 | } |
1801 | } | |
a15bc651 NS |
1802 | } |
1803 | ||
1804 | if (!found) { | |
1805 | if(! opt_programid) { | |
1806 | /* try again and reuse existing stream */ | |
1807 | for(j=0;j<nb_istreams;j++) { | |
1808 | ist = ist_table[j]; | |
1809 | if (ist->st->codec->codec_type == ost->st->codec->codec_type) { | |
1810 | ost->source_index = j; | |
1811 | found = 1; | |
1812 | } | |
1813 | } | |
50e143c4 | 1814 | } |
85f07f22 | 1815 | if (!found) { |
462cca10 SS |
1816 | int i= ost->file_index; |
1817 | dump_format(output_files[i], i, output_files[i]->filename, 1); | |
85f07f22 FB |
1818 | fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n", |
1819 | ost->file_index, ost->index); | |
296df4e7 | 1820 | av_exit(1); |
85f07f22 FB |
1821 | } |
1822 | } | |
1823 | } | |
1824 | ist = ist_table[ost->source_index]; | |
1825 | ist->discard = 0; | |
b4a3389e | 1826 | ost->sync_ist = (nb_stream_maps > 0) ? |
de427ff4 SS |
1827 | ist_table[file_table[stream_maps[n].sync_file_index].ist_index + |
1828 | stream_maps[n].sync_stream_index] : ist; | |
85f07f22 FB |
1829 | } |
1830 | } | |
1831 | ||
85f07f22 FB |
1832 | /* for each output stream, we compute the right encoding parameters */ |
1833 | for(i=0;i<nb_ostreams;i++) { | |
0a789246 | 1834 | AVMetadataTag *lang; |
85f07f22 | 1835 | ost = ost_table[i]; |
365515ac | 1836 | os = output_files[ost->file_index]; |
85f07f22 FB |
1837 | ist = ist_table[ost->source_index]; |
1838 | ||
01f4895c MN |
1839 | codec = ost->st->codec; |
1840 | icodec = ist->st->codec; | |
85f07f22 | 1841 | |
0a789246 AJ |
1842 | if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0)) |
1843 | && !av_metadata_get(ost->st->metadata, "language", NULL, 0)) | |
1844 | av_metadata_set(&ost->st->metadata, "language", lang->value); | |
8e0d882b | 1845 | |
90c2295b | 1846 | ost->st->disposition = ist->st->disposition; |
a39b76ea | 1847 | codec->bits_per_raw_sample= icodec->bits_per_raw_sample; |
de961801 | 1848 | codec->chroma_sample_location = icodec->chroma_sample_location; |
90c2295b | 1849 | |
1629626f FB |
1850 | if (ost->st->stream_copy) { |
1851 | /* if stream_copy is selected, no need to decode or encode */ | |
1852 | codec->codec_id = icodec->codec_id; | |
1853 | codec->codec_type = icodec->codec_type; | |
365515ac MN |
1854 | |
1855 | if(!codec->codec_tag){ | |
1856 | if( !os->oformat->codec_tag | |
1857 | || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0 | |
1858 | || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0) | |
1859 | codec->codec_tag = icodec->codec_tag; | |
1860 | } | |
1861 | ||
1629626f | 1862 | codec->bit_rate = icodec->bit_rate; |
dffbfd06 MN |
1863 | codec->extradata= icodec->extradata; |
1864 | codec->extradata_size= icodec->extradata_size; | |
3797c74b | 1865 | 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){ |
d29de719 | 1866 | codec->time_base = icodec->time_base; |
3797c74b MN |
1867 | codec->time_base.num *= icodec->ticks_per_frame; |
1868 | }else | |
d29de719 | 1869 | codec->time_base = ist->st->time_base; |
1629626f FB |
1870 | switch(codec->codec_type) { |
1871 | case CODEC_TYPE_AUDIO: | |
d08e3e91 RP |
1872 | if(audio_volume != 256) { |
1873 | fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n"); | |
1874 | av_exit(1); | |
1875 | } | |
13367a46 | 1876 | codec->channel_layout = icodec->channel_layout; |
1629626f FB |
1877 | codec->sample_rate = icodec->sample_rate; |
1878 | codec->channels = icodec->channels; | |
0a3b0447 | 1879 | codec->frame_size = icodec->frame_size; |
c1344911 | 1880 | codec->block_align= icodec->block_align; |
4efd6f58 MN |
1881 | if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3) |
1882 | codec->block_align= 0; | |
bcbd328e MN |
1883 | if(codec->codec_id == CODEC_ID_AC3) |
1884 | codec->block_align= 0; | |
1629626f FB |
1885 | break; |
1886 | case CODEC_TYPE_VIDEO: | |
9df3437f | 1887 | codec->pix_fmt = icodec->pix_fmt; |
1629626f FB |
1888 | codec->width = icodec->width; |
1889 | codec->height = icodec->height; | |
ff8cc24b | 1890 | codec->has_b_frames = icodec->has_b_frames; |
1629626f | 1891 | break; |
cf7fc795 | 1892 | case CODEC_TYPE_SUBTITLE: |
d43b26ea DC |
1893 | codec->width = icodec->width; |
1894 | codec->height = icodec->height; | |
cf7fc795 | 1895 | break; |
1629626f | 1896 | default: |
0f4e8165 | 1897 | abort(); |
1629626f FB |
1898 | } |
1899 | } else { | |
1900 | switch(codec->codec_type) { | |
1901 | case CODEC_TYPE_AUDIO: | |
41dd680d MN |
1902 | ost->fifo= av_fifo_alloc(1024); |
1903 | if(!ost->fifo) | |
85f07f22 | 1904 | goto fail; |
a79db0f7 | 1905 | ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE); |
2886f311 AĂ– |
1906 | ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1; |
1907 | icodec->request_channels = codec->channels; | |
85f07f22 FB |
1908 | ist->decoding_needed = 1; |
1909 | ost->encoding_needed = 1; | |
1629626f FB |
1910 | break; |
1911 | case CODEC_TYPE_VIDEO: | |
761c8c92 BC |
1912 | if (ost->st->codec->pix_fmt == PIX_FMT_NONE) { |
1913 | fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n"); | |
1914 | av_exit(1); | |
1915 | } | |
c3f11d19 LA |
1916 | ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0); |
1917 | ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0); | |
1918 | ost->video_resample = ((codec->width != icodec->width - | |
1919 | (frame_leftBand + frame_rightBand) + | |
1920 | (frame_padleft + frame_padright)) || | |
1921 | (codec->height != icodec->height - | |
1922 | (frame_topBand + frame_bottomBand) + | |
18a54b04 LA |
1923 | (frame_padtop + frame_padbottom)) || |
1924 | (codec->pix_fmt != icodec->pix_fmt)); | |
c3f11d19 | 1925 | if (ost->video_crop) { |
352666c1 EB |
1926 | ost->topBand = ost->original_topBand = frame_topBand; |
1927 | ost->bottomBand = ost->original_bottomBand = frame_bottomBand; | |
1928 | ost->leftBand = ost->original_leftBand = frame_leftBand; | |
1929 | ost->rightBand = ost->original_rightBand = frame_rightBand; | |
c3f11d19 LA |
1930 | } |
1931 | if (ost->video_pad) { | |
1ff93ffc TK |
1932 | ost->padtop = frame_padtop; |
1933 | ost->padleft = frame_padleft; | |
1934 | ost->padbottom = frame_padbottom; | |
1935 | ost->padright = frame_padright; | |
c3f11d19 LA |
1936 | if (!ost->video_resample) { |
1937 | avcodec_get_frame_defaults(&ost->pict_tmp); | |
9d58e0a9 BC |
1938 | if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt, |
1939 | codec->width, codec->height)) | |
c3f11d19 LA |
1940 | goto fail; |
1941 | } | |
1942 | } | |
1943 | if (ost->video_resample) { | |
2de28abb | 1944 | avcodec_get_frame_defaults(&ost->pict_tmp); |
9d58e0a9 BC |
1945 | if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt, |
1946 | codec->width, codec->height)) { | |
eddc482d | 1947 | fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n"); |
296df4e7 | 1948 | av_exit(1); |
eddc482d | 1949 | } |
9de8e6ac | 1950 | sws_flags = av_get_int(sws_opts, "sws_flags", NULL); |
18a54b04 LA |
1951 | ost->img_resample_ctx = sws_getContext( |
1952 | icodec->width - (frame_leftBand + frame_rightBand), | |
1953 | icodec->height - (frame_topBand + frame_bottomBand), | |
1954 | icodec->pix_fmt, | |
07d0cdfc LA |
1955 | codec->width - (frame_padleft + frame_padright), |
1956 | codec->height - (frame_padtop + frame_padbottom), | |
18a54b04 LA |
1957 | codec->pix_fmt, |
1958 | sws_flags, NULL, NULL, NULL); | |
0b50ac8a LA |
1959 | if (ost->img_resample_ctx == NULL) { |
1960 | fprintf(stderr, "Cannot get resampling context\n"); | |
296df4e7 | 1961 | av_exit(1); |
0b50ac8a | 1962 | } |
352666c1 EB |
1963 | |
1964 | ost->original_height = icodec->height; | |
1965 | ost->original_width = icodec->width; | |
1966 | ||
a39b76ea | 1967 | codec->bits_per_raw_sample= 0; |
85f07f22 | 1968 | } |
b83ccbff MN |
1969 | ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand); |
1970 | ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand); | |
1971 | ost->resample_pix_fmt= icodec->pix_fmt; | |
85f07f22 FB |
1972 | ost->encoding_needed = 1; |
1973 | ist->decoding_needed = 1; | |
1629626f | 1974 | break; |
cf7fc795 FB |
1975 | case CODEC_TYPE_SUBTITLE: |
1976 | ost->encoding_needed = 1; | |
1977 | ist->decoding_needed = 1; | |
1978 | break; | |
1629626f | 1979 | default: |
0f4e8165 | 1980 | abort(); |
cf7fc795 | 1981 | break; |
85f07f22 | 1982 | } |
1629626f | 1983 | /* two pass mode */ |
115329f1 | 1984 | if (ost->encoding_needed && |
1629626f FB |
1985 | (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) { |
1986 | char logfilename[1024]; | |
1987 | FILE *f; | |
1988 | int size; | |
1989 | char *logbuffer; | |
115329f1 DB |
1990 | |
1991 | snprintf(logfilename, sizeof(logfilename), "%s-%d.log", | |
22730e87 SS |
1992 | pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX, |
1993 | i); | |
1629626f FB |
1994 | if (codec->flags & CODEC_FLAG_PASS1) { |
1995 | f = fopen(logfilename, "w"); | |
1996 | if (!f) { | |
42d1d06e | 1997 | fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno)); |
296df4e7 | 1998 | av_exit(1); |
1629626f FB |
1999 | } |
2000 | ost->logfile = f; | |
2001 | } else { | |
2002 | /* read the log file */ | |
2003 | f = fopen(logfilename, "r"); | |
2004 | if (!f) { | |
42d1d06e | 2005 | fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno)); |
296df4e7 | 2006 | av_exit(1); |
1629626f FB |
2007 | } |
2008 | fseek(f, 0, SEEK_END); | |
2009 | size = ftell(f); | |
2010 | fseek(f, 0, SEEK_SET); | |
2011 | logbuffer = av_malloc(size + 1); | |
2012 | if (!logbuffer) { | |
2013 | fprintf(stderr, "Could not allocate log buffer\n"); | |
296df4e7 | 2014 | av_exit(1); |
1629626f | 2015 | } |
4776fa92 | 2016 | size = fread(logbuffer, 1, size, f); |
1629626f FB |
2017 | fclose(f); |
2018 | logbuffer[size] = '\0'; | |
2019 | codec->stats_in = logbuffer; | |
5abdb4b1 | 2020 | } |
5abdb4b1 FB |
2021 | } |
2022 | } | |
8a6cb114 MN |
2023 | if(codec->codec_type == CODEC_TYPE_VIDEO){ |
2024 | int size= codec->width * codec->height; | |
c027e91a | 2025 | bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200); |
8a6cb114 | 2026 | } |
85f07f22 FB |
2027 | } |
2028 | ||
8a6cb114 MN |
2029 | if (!bit_buffer) |
2030 | bit_buffer = av_malloc(bit_buffer_size); | |
002c95d7 | 2031 | if (!bit_buffer) { |
50f3fabc MR |
2032 | fprintf(stderr, "Cannot allocate %d bytes output buffer\n", |
2033 | bit_buffer_size); | |
002c95d7 | 2034 | ret = AVERROR(ENOMEM); |
8a6cb114 | 2035 | goto fail; |
1629626f FB |
2036 | } |
2037 | ||
85f07f22 FB |
2038 | /* open each encoder */ |
2039 | for(i=0;i<nb_ostreams;i++) { | |
2040 | ost = ost_table[i]; | |
2041 | if (ost->encoding_needed) { | |
6488cf9b AJ |
2042 | AVCodec *codec = output_codecs[i]; |
2043 | if (!codec) | |
fd2b356a | 2044 | codec = avcodec_find_encoder(ost->st->codec->codec_id); |
85f07f22 | 2045 | if (!codec) { |
f356fc57 BC |
2046 | snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d", |
2047 | ost->st->codec->codec_id, ost->file_index, ost->index); | |
002c95d7 BC |
2048 | ret = AVERROR(EINVAL); |
2049 | goto dump_format; | |
85f07f22 | 2050 | } |
01f4895c | 2051 | if (avcodec_open(ost->st->codec, codec) < 0) { |
f356fc57 | 2052 | snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height", |
85f07f22 | 2053 | ost->file_index, ost->index); |
002c95d7 BC |
2054 | ret = AVERROR(EINVAL); |
2055 | goto dump_format; | |
85f07f22 | 2056 | } |
01f4895c | 2057 | extra_size += ost->st->codec->extradata_size; |
85f07f22 FB |
2058 | } |
2059 | } | |
2060 | ||
2061 | /* open each decoder */ | |
2062 | for(i=0;i<nb_istreams;i++) { | |
2063 | ist = ist_table[i]; | |
2064 | if (ist->decoding_needed) { | |
6488cf9b AJ |
2065 | AVCodec *codec = input_codecs[i]; |
2066 | if (!codec) | |
fd2b356a | 2067 | codec = avcodec_find_decoder(ist->st->codec->codec_id); |
85f07f22 | 2068 | if (!codec) { |
f356fc57 | 2069 | snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d", |
01f4895c | 2070 | ist->st->codec->codec_id, ist->file_index, ist->index); |
002c95d7 BC |
2071 | ret = AVERROR(EINVAL); |
2072 | goto dump_format; | |
85f07f22 | 2073 | } |
01f4895c | 2074 | if (avcodec_open(ist->st->codec, codec) < 0) { |
f356fc57 | 2075 | snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d", |
85f07f22 | 2076 | ist->file_index, ist->index); |
002c95d7 BC |
2077 | ret = AVERROR(EINVAL); |
2078 | goto dump_format; | |
85f07f22 | 2079 | } |
01f4895c MN |
2080 | //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) |
2081 | // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD; | |
85f07f22 FB |
2082 | } |
2083 | } | |
2084 | ||
2085 | /* init pts */ | |
2086 | for(i=0;i<nb_istreams;i++) { | |
2087 | ist = ist_table[i]; | |
e7d0374f | 2088 | ist->pts = 0; |
48291040 | 2089 | ist->next_pts = AV_NOPTS_VALUE; |
ff4905a5 | 2090 | ist->is_start = 1; |
85f07f22 | 2091 | } |
bd1b79a1 | 2092 | |
0a38bafd PB |
2093 | /* set meta data information from input file if required */ |
2094 | for (i=0;i<nb_meta_data_maps;i++) { | |
2095 | AVFormatContext *out_file; | |
2096 | AVFormatContext *in_file; | |
a5926d85 | 2097 | AVMetadataTag *mtag; |
0a38bafd PB |
2098 | |
2099 | int out_file_index = meta_data_maps[i].out_file; | |
2100 | int in_file_index = meta_data_maps[i].in_file; | |
9d58e0a9 | 2101 | if (out_file_index < 0 || out_file_index >= nb_output_files) { |
002c95d7 BC |
2102 | snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)", |
2103 | out_file_index, out_file_index, in_file_index); | |
8fa36ae0 | 2104 | ret = AVERROR(EINVAL); |
002c95d7 | 2105 | goto dump_format; |
0a38bafd | 2106 | } |
9d58e0a9 | 2107 | if (in_file_index < 0 || in_file_index >= nb_input_files) { |
002c95d7 BC |
2108 | snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)", |
2109 | in_file_index, out_file_index, in_file_index); | |
8fa36ae0 | 2110 | ret = AVERROR(EINVAL); |
002c95d7 | 2111 | goto dump_format; |
115329f1 DB |
2112 | } |
2113 | ||
0a38bafd PB |
2114 | out_file = output_files[out_file_index]; |
2115 | in_file = input_files[in_file_index]; | |
2116 | ||
a5926d85 AJ |
2117 | |
2118 | mtag=NULL; | |
2119 | while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX))) | |
2120 | av_metadata_set(&out_file->metadata, mtag->key, mtag->value); | |
2121 | av_metadata_conv(out_file, out_file->oformat->metadata_conv, | |
2122 | in_file->iformat->metadata_conv); | |
0a38bafd | 2123 | } |
115329f1 | 2124 | |
85f07f22 FB |
2125 | /* open files and write file headers */ |
2126 | for(i=0;i<nb_output_files;i++) { | |
2127 | os = output_files[i]; | |
79fdaa4c | 2128 | if (av_write_header(os) < 0) { |
002c95d7 | 2129 | snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i); |
8fa36ae0 | 2130 | ret = AVERROR(EINVAL); |
002c95d7 | 2131 | goto dump_format; |
a38469e1 | 2132 | } |
6d1ba1ac LA |
2133 | if (strcmp(output_files[i]->oformat->name, "rtp")) { |
2134 | want_sdp = 0; | |
2135 | } | |
2136 | } | |
002c95d7 BC |
2137 | |
2138 | dump_format: | |
2139 | /* dump the file output parameters - cannot be done before in case | |
2140 | of stream copy */ | |
2141 | for(i=0;i<nb_output_files;i++) { | |
2142 | dump_format(output_files[i], i, output_files[i]->filename, 1); | |
2143 | } | |
2144 | ||
2145 | /* dump the stream mapping */ | |
2146 | if (verbose >= 0) { | |
2147 | fprintf(stderr, "Stream mapping:\n"); | |
2148 | for(i=0;i<nb_ostreams;i++) { | |
2149 | ost = ost_table[i]; | |
2150 | fprintf(stderr, " Stream #%d.%d -> #%d.%d", | |
2151 | ist_table[ost->source_index]->file_index, | |
2152 | ist_table[ost->source_index]->index, | |
2153 | ost->file_index, | |
2154 | ost->index); | |
2155 | if (ost->sync_ist != ist_table[ost->source_index]) | |
2156 | fprintf(stderr, " [sync #%d.%d]", | |
2157 | ost->sync_ist->file_index, | |
2158 | ost->sync_ist->index); | |
2159 | fprintf(stderr, "\n"); | |
2160 | } | |
2161 | } | |
2162 | ||
2163 | if (ret) { | |
2164 | fprintf(stderr, "%s\n", error); | |
2165 | goto fail; | |
2166 | } | |
2167 | ||
6d1ba1ac LA |
2168 | if (want_sdp) { |
2169 | print_sdp(output_files, nb_output_files); | |
85f07f22 FB |
2170 | } |
2171 | ||
9d58e0a9 | 2172 | if (!using_stdin && verbose >= 0) { |
d9a916e2 | 2173 | fprintf(stderr, "Press [q] to stop encoding\n"); |
b51469a0 LS |
2174 | url_set_interrupt_cb(decode_interrupt_cb); |
2175 | } | |
a38469e1 FB |
2176 | term_init(); |
2177 | ||
7fc98937 | 2178 | timer_start = av_gettime(); |
51bd4565 | 2179 | |
d9a916e2 | 2180 | for(; received_sigterm == 0;) { |
85f07f22 FB |
2181 | int file_index, ist_index; |
2182 | AVPacket pkt; | |
a9aeda81 PB |
2183 | double ipts_min; |
2184 | double opts_min; | |
23ffe323 | 2185 | |
85f07f22 | 2186 | redo: |
a9aeda81 PB |
2187 | ipts_min= 1e100; |
2188 | opts_min= 1e100; | |
a38469e1 | 2189 | /* if 'q' pressed, exits */ |
d9a916e2 | 2190 | if (!using_stdin) { |
b51469a0 LS |
2191 | if (q_pressed) |
2192 | break; | |
cb09b2ed PG |
2193 | /* read_key() returns 0 on EOF */ |
2194 | key = read_key(); | |
2195 | if (key == 'q') | |
2196 | break; | |
2197 | } | |
a38469e1 | 2198 | |
ec5517d5 FB |
2199 | /* select the stream that we must read now by looking at the |
2200 | smallest output pts */ | |
85f07f22 | 2201 | file_index = -1; |
ec5517d5 | 2202 | for(i=0;i<nb_ostreams;i++) { |
23ffe323 | 2203 | double ipts, opts; |
ec5517d5 FB |
2204 | ost = ost_table[i]; |
2205 | os = output_files[ost->file_index]; | |
2206 | ist = ist_table[ost->source_index]; | |
545465ec MN |
2207 | if(no_packet[ist->file_index]) |
2208 | continue; | |
01f4895c MN |
2209 | if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO) |
2210 | opts = ost->sync_opts * av_q2d(ost->st->codec->time_base); | |
23ffe323 | 2211 | else |
c0df9d75 | 2212 | opts = ost->st->pts.val * av_q2d(ost->st->time_base); |
23ffe323 MN |
2213 | ipts = (double)ist->pts; |
2214 | if (!file_table[ist->file_index].eof_reached){ | |
2215 | if(ipts < ipts_min) { | |
2216 | ipts_min = ipts; | |
2217 | if(input_sync ) file_index = ist->file_index; | |
2218 | } | |
2219 | if(opts < opts_min) { | |
2220 | opts_min = opts; | |
2221 | if(!input_sync) file_index = ist->file_index; | |
2222 | } | |
85f07f22 | 2223 | } |
01f4895c | 2224 | if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){ |
7ca60994 MN |
2225 | file_index= -1; |
2226 | break; | |
2227 | } | |
85f07f22 FB |
2228 | } |
2229 | /* if none, if is finished */ | |
51bd4565 | 2230 | if (file_index < 0) { |
545465ec MN |
2231 | if(no_packet_count){ |
2232 | no_packet_count=0; | |
2233 | memset(no_packet, 0, sizeof(no_packet)); | |
d61f30a7 | 2234 | usleep(10000); |
545465ec MN |
2235 | continue; |
2236 | } | |
85f07f22 | 2237 | break; |
ec5517d5 FB |
2238 | } |
2239 | ||
85f07f22 | 2240 | /* finish if recording time exhausted */ |
fc7ad2af | 2241 | if (opts_min >= (recording_time / 1000000.0)) |
85f07f22 | 2242 | break; |
ec5517d5 | 2243 | |
b6e16b86 | 2244 | /* finish if limit size exhausted */ |
899681cd | 2245 | if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb)) |
b6e16b86 C |
2246 | break; |
2247 | ||
254abc2e | 2248 | /* read a frame from it and output it in the fifo */ |
85f07f22 | 2249 | is = input_files[file_index]; |
ad51c68c | 2250 | ret= av_read_frame(is, &pkt); |
b9edbe99 | 2251 | if(ret == AVERROR(EAGAIN)){ |
545465ec MN |
2252 | no_packet[file_index]=1; |
2253 | no_packet_count++; | |
ad51c68c | 2254 | continue; |
545465ec | 2255 | } |
ad51c68c | 2256 | if (ret < 0) { |
85f07f22 | 2257 | file_table[file_index].eof_reached = 1; |
d24ce947 AB |
2258 | if (opt_shortest) |
2259 | break; | |
2260 | else | |
2261 | continue; | |
85f07f22 | 2262 | } |
303e50e6 | 2263 | |
545465ec MN |
2264 | no_packet_count=0; |
2265 | memset(no_packet, 0, sizeof(no_packet)); | |
2266 | ||
254abc2e | 2267 | if (do_pkt_dump) { |
750f0e1f | 2268 | av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump); |
817b23ff | 2269 | } |
79fdaa4c FB |
2270 | /* the following test is needed in case new streams appear |
2271 | dynamically in stream : we ignore them */ | |
2272 | if (pkt.stream_index >= file_table[file_index].nb_streams) | |
bf5af568 | 2273 | goto discard_packet; |
85f07f22 FB |
2274 | ist_index = file_table[file_index].ist_index + pkt.stream_index; |
2275 | ist = ist_table[ist_index]; | |
bf5af568 FB |
2276 | if (ist->discard) |
2277 | goto discard_packet; | |
85f07f22 | 2278 | |
fec401f7 MN |
2279 | if (pkt.dts != AV_NOPTS_VALUE) |
2280 | pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base); | |
2281 | if (pkt.pts != AV_NOPTS_VALUE) | |
2282 | pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base); | |
2283 | ||
8833f375 MN |
2284 | if(input_files_ts_scale[file_index][pkt.stream_index]){ |
2285 | if(pkt.pts != AV_NOPTS_VALUE) | |
2286 | pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index]; | |
2287 | if(pkt.dts != AV_NOPTS_VALUE) | |
2288 | pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index]; | |
2289 | } | |
2290 | ||
949b1a13 | 2291 | // 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); |
965530e1 MN |
2292 | if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE |
2293 | && (is->iformat->flags & AVFMT_TS_DISCONT)) { | |
81d6d520 MN |
2294 | int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q); |
2295 | int64_t delta= pkt_dts - ist->next_pts; | |
2296 | if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){ | |
72bd8100 MN |
2297 | input_files_ts_offset[ist->file_index]-= delta; |
2298 | if (verbose > 2) | |
4733abcb | 2299 | fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]); |
fec401f7 MN |
2300 | pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base); |
2301 | if(pkt.pts != AV_NOPTS_VALUE) | |
2302 | pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base); | |
72bd8100 MN |
2303 | } |
2304 | } | |
2305 | ||
8831db5c | 2306 | //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size); |
a700a6ae | 2307 | if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) { |
d8019eb5 AD |
2308 | |
2309 | if (verbose >= 0) | |
2310 | fprintf(stderr, "Error while decoding stream #%d.%d\n", | |
2311 | ist->file_index, ist->index); | |
f2abc559 BC |
2312 | if (exit_on_error) |
2313 | av_exit(1); | |
a700a6ae FB |
2314 | av_free_packet(&pkt); |
2315 | goto redo; | |
fe08925f | 2316 | } |
cf7fc795 | 2317 | |
bf5af568 | 2318 | discard_packet: |
85f07f22 | 2319 | av_free_packet(&pkt); |
115329f1 | 2320 | |
ec5517d5 FB |
2321 | /* dump report by using the output first video and audio streams */ |
2322 | print_report(output_files, ost_table, nb_ostreams, 0); | |
85f07f22 | 2323 | } |
a700a6ae FB |
2324 | |
2325 | /* at the end of stream, we must flush the decoder buffers */ | |
2326 | for(i=0;i<nb_istreams;i++) { | |
2327 | ist = ist_table[i]; | |
2328 | if (ist->decoding_needed) { | |
2329 | output_packet(ist, i, ost_table, nb_ostreams, NULL); | |
2330 | } | |
2331 | } | |
2332 | ||
a38469e1 | 2333 | term_exit(); |
85f07f22 | 2334 | |
c4e37247 MN |
2335 | /* write the trailer if needed and close file */ |
2336 | for(i=0;i<nb_output_files;i++) { | |
2337 | os = output_files[i]; | |
2338 | av_write_trailer(os); | |
2339 | } | |
2340 | ||
37f5cd5a MN |
2341 | /* dump report by using the first video and audio streams */ |
2342 | print_report(output_files, ost_table, nb_ostreams, 1); | |
2343 | ||
85f07f22 FB |
2344 | /* close each encoder */ |
2345 | for(i=0;i<nb_ostreams;i++) { | |
2346 | ost = ost_table[i]; | |
2347 | if (ost->encoding_needed) { | |
01f4895c MN |
2348 | av_freep(&ost->st->codec->stats_in); |
2349 | avcodec_close(ost->st->codec); | |
85f07f22 FB |
2350 | } |
2351 | } | |
115329f1 | 2352 | |
85f07f22 FB |
2353 | /* close each decoder */ |
2354 | for(i=0;i<nb_istreams;i++) { | |
2355 | ist = ist_table[i]; | |
2356 | if (ist->decoding_needed) { | |
01f4895c | 2357 | avcodec_close(ist->st->codec); |
85f07f22 FB |
2358 | } |
2359 | } | |
85f07f22 | 2360 | |
85f07f22 | 2361 | /* finished ! */ |
00b7fbdc | 2362 | ret = 0; |
115329f1 | 2363 | |
002c95d7 | 2364 | fail: |
83b07470 | 2365 | av_freep(&bit_buffer); |
0f1578af | 2366 | av_free(file_table); |
bdc4796f | 2367 | |
85f07f22 FB |
2368 | if (ist_table) { |
2369 | for(i=0;i<nb_istreams;i++) { | |
2370 | ist = ist_table[i]; | |
0f1578af | 2371 | av_free(ist); |
85f07f22 | 2372 | } |
0f1578af | 2373 | av_free(ist_table); |
85f07f22 FB |
2374 | } |
2375 | if (ost_table) { | |
2376 | for(i=0;i<nb_ostreams;i++) { | |
2377 | ost = ost_table[i]; | |
2378 | if (ost) { | |
5abdb4b1 FB |
2379 | if (ost->logfile) { |
2380 | fclose(ost->logfile); | |
2381 | ost->logfile = NULL; | |
2382 | } | |
41dd680d | 2383 | av_fifo_free(ost->fifo); /* works even if fifo is not |
f5a478f6 | 2384 | initialized but set to zero */ |
0f1578af | 2385 | av_free(ost->pict_tmp.data[0]); |
85f07f22 | 2386 | if (ost->video_resample) |
18a54b04 | 2387 | sws_freeContext(ost->img_resample_ctx); |
8e4270c5 | 2388 | if (ost->resample) |
85f07f22 | 2389 | audio_resample_close(ost->resample); |
a79db0f7 PR |
2390 | if (ost->reformat_ctx) |
2391 | av_audio_convert_free(ost->reformat_ctx); | |
0f1578af | 2392 | av_free(ost); |
85f07f22 FB |
2393 | } |
2394 | } | |
0f1578af | 2395 | av_free(ost_table); |
85f07f22 FB |
2396 | } |
2397 | return ret; | |
85f07f22 FB |
2398 | } |
2399 | ||
b29f97d1 | 2400 | static void opt_format(const char *arg) |
85f07f22 | 2401 | { |
817b23ff FB |
2402 | /* compatibility stuff for pgmyuv */ |
2403 | if (!strcmp(arg, "pgmyuv")) { | |
5b6d5596 | 2404 | pgmyuv_compatibility_hack=1; |
9286699a | 2405 | // opt_image_format(arg); |
5b6d5596 | 2406 | arg = "image2"; |
17ceb4f9 | 2407 | fprintf(stderr, "pgmyuv format is deprecated, use image2\n"); |
817b23ff FB |
2408 | } |
2409 | ||
a5abfd8f | 2410 | last_asked_format = arg; |
85f07f22 FB |
2411 | } |
2412 | ||
464a631c | 2413 | static void opt_video_rc_override_string(const char *arg) |
ac2830ec MN |
2414 | { |
2415 | video_rc_override_string = arg; | |
2416 | } | |
2417 | ||
c48da33c | 2418 | static int opt_me_threshold(const char *opt, const char *arg) |
f4f3223f | 2419 | { |
c48da33c SS |
2420 | me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX); |
2421 | return 0; | |
f4f3223f MN |
2422 | } |
2423 | ||
c48da33c | 2424 | static int opt_verbose(const char *opt, const char *arg) |
f068206e | 2425 | { |
46eab093 | 2426 | verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10); |
c48da33c | 2427 | return 0; |
f068206e BE |
2428 | } |
2429 | ||
2fc3866d | 2430 | static int opt_frame_rate(const char *opt, const char *arg) |
85f07f22 | 2431 | { |
b33ece16 | 2432 | if (av_parse_video_frame_rate(&frame_rate, arg) < 0) { |
2fc3866d | 2433 | fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg); |
296df4e7 | 2434 | av_exit(1); |
445f1b83 | 2435 | } |
2fc3866d | 2436 | return 0; |
85f07f22 FB |
2437 | } |
2438 | ||
ebde2a2c | 2439 | static int opt_bitrate(const char *opt, const char *arg) |
1b1656c6 RP |
2440 | { |
2441 | int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO; | |
2442 | ||
2443 | opt_default(opt, arg); | |
2444 | ||
636f1c4c | 2445 | if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000) |
1b1656c6 | 2446 | fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n"); |
ebde2a2c MH |
2447 | |
2448 | return 0; | |
1b1656c6 RP |
2449 | } |
2450 | ||
b29f97d1 | 2451 | static void opt_frame_crop_top(const char *arg) |
ab6d194a | 2452 | { |
115329f1 | 2453 | frame_topBand = atoi(arg); |
ab6d194a MN |
2454 | if (frame_topBand < 0) { |
2455 | fprintf(stderr, "Incorrect top crop size\n"); | |
296df4e7 | 2456 | av_exit(1); |
ab6d194a | 2457 | } |
ab6d194a | 2458 | if ((frame_topBand) >= frame_height){ |
bb270c08 | 2459 | fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); |
296df4e7 | 2460 | av_exit(1); |
ab6d194a MN |
2461 | } |
2462 | frame_height -= frame_topBand; | |
2463 | } | |
2464 | ||
b29f97d1 | 2465 | static void opt_frame_crop_bottom(const char *arg) |
ab6d194a MN |
2466 | { |
2467 | frame_bottomBand = atoi(arg); | |
2468 | if (frame_bottomBand < 0) { | |
2469 | fprintf(stderr, "Incorrect bottom crop size\n"); | |
296df4e7 | 2470 | av_exit(1); |
ab6d194a | 2471 | } |
ab6d194a | 2472 | if ((frame_bottomBand) >= frame_height){ |
bb270c08 | 2473 | fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); |
296df4e7 | 2474 | av_exit(1); |
ab6d194a MN |
2475 | } |
2476 | frame_height -= frame_bottomBand; | |
2477 | } | |
2478 | ||
b29f97d1 | 2479 | static void opt_frame_crop_left(const char *arg) |
ab6d194a MN |
2480 | { |
2481 | frame_leftBand = atoi(arg); | |
2482 | if (frame_leftBand < 0) { | |
2483 | fprintf(stderr, "Incorrect left crop size\n"); | |
296df4e7 | 2484 | av_exit(1); |
ab6d194a | 2485 | } |
ab6d194a | 2486 | if ((frame_leftBand) >= frame_width){ |
bb270c08 | 2487 | fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); |
296df4e7 | 2488 | av_exit(1); |
ab6d194a MN |
2489 | } |
2490 | frame_width -= frame_leftBand; | |
2491 | } | |
2492 | ||
b29f97d1 | 2493 | static void opt_frame_crop_right(const char *arg) |
ab6d194a MN |
2494 | { |
2495 | frame_rightBand = atoi(arg); | |
2496 | if (frame_rightBand < 0) { | |
2497 | fprintf(stderr, "Incorrect right crop size\n"); | |
296df4e7 | 2498 | av_exit(1); |
ab6d194a | 2499 | } |
ab6d194a | 2500 | if ((frame_rightBand) >= frame_width){ |
bb270c08 | 2501 | fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); |
296df4e7 | 2502 | av_exit(1); |
ab6d194a MN |
2503 | } |
2504 | frame_width -= frame_rightBand; | |
2505 | } | |
2506 | ||
b29f97d1 | 2507 | static void opt_frame_size(const char *arg) |
85f07f22 | 2508 | { |
b33ece16 | 2509 | if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) { |
85f07f22 | 2510 | fprintf(stderr, "Incorrect frame size\n"); |
296df4e7 | 2511 | av_exit(1); |
85f07f22 | 2512 | } |
85f07f22 FB |
2513 | } |
2514 | ||
1ff93ffc TK |
2515 | static void opt_pad_color(const char *arg) { |
2516 | /* Input is expected to be six hex digits similar to | |
2517 | how colors are expressed in html tags (but without the #) */ | |
2518 | int rgb = strtol(arg, NULL, 16); | |
2519 | int r,g,b; | |
115329f1 DB |
2520 | |
2521 | r = (rgb >> 16); | |
1ff93ffc TK |
2522 | g = ((rgb >> 8) & 255); |
2523 | b = (rgb & 255); | |
2524 | ||
2525 | padcolor[0] = RGB_TO_Y(r,g,b); | |
2526 | padcolor[1] = RGB_TO_U(r,g,b,0); | |
2527 | padcolor[2] = RGB_TO_V(r,g,b,0); | |
2528 | } | |
2529 | ||
2530 | static void opt_frame_pad_top(const char *arg) | |
2531 | { | |
115329f1 | 2532 | frame_padtop = atoi(arg); |
1ff93ffc TK |
2533 | if (frame_padtop < 0) { |
2534 | fprintf(stderr, "Incorrect top pad size\n"); | |
296df4e7 | 2535 | av_exit(1); |
1ff93ffc | 2536 | } |
1ff93ffc TK |
2537 | } |
2538 | ||
2539 | static void opt_frame_pad_bottom(const char *arg) | |
2540 | { | |
115329f1 | 2541 | frame_padbottom = atoi(arg); |
1ff93ffc TK |
2542 | if (frame_padbottom < 0) { |
2543 | fprintf(stderr, "Incorrect bottom pad size\n"); | |
296df4e7 | 2544 | av_exit(1); |
1ff93ffc | 2545 | } |
1ff93ffc TK |
2546 | } |
2547 | ||
2548 | ||
2549 | static void opt_frame_pad_left(const char *arg) | |
2550 | { | |
115329f1 | 2551 | frame_padleft = atoi(arg); |
1ff93ffc TK |
2552 | if (frame_padleft < 0) { |
2553 | fprintf(stderr, "Incorrect left pad size\n"); | |
296df4e7 | 2554 | av_exit(1); |
1ff93ffc | 2555 | } |
1ff93ffc TK |
2556 | } |
2557 | ||
2558 | ||
2559 | static void opt_frame_pad_right(const char *arg) | |
2560 | { | |
115329f1 | 2561 | frame_padright = atoi(arg); |
1ff93ffc TK |
2562 | if (frame_padright < 0) { |
2563 | fprintf(stderr, "Incorrect right pad size\n"); | |
296df4e7 | 2564 | av_exit(1); |
1ff93ffc | 2565 | } |
1ff93ffc TK |
2566 | } |
2567 | ||
63167088 RS |
2568 | static void opt_frame_pix_fmt(const char *arg) |
2569 | { | |
90da2b50 | 2570 | if (strcmp(arg, "list")) { |
c3b95b1d | 2571 | frame_pix_fmt = avcodec_get_pix_fmt(arg); |
90da2b50 SS |
2572 | if (frame_pix_fmt == PIX_FMT_NONE) { |
2573 | fprintf(stderr, "Unknown pixel format requested: %s\n", arg); | |
2574 | av_exit(1); | |
2575 | } | |
2576 | } else { | |
ce1ee094 | 2577 | list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB); |
296df4e7 | 2578 | av_exit(0); |
c3b95b1d | 2579 | } |
63167088 RS |
2580 | } |
2581 | ||
5fe03e38 RS |
2582 | static void opt_frame_aspect_ratio(const char *arg) |
2583 | { | |
2584 | int x = 0, y = 0; | |
2585 | double ar = 0; | |
2586 | const char *p; | |
815f98cc | 2587 | char *end; |
115329f1 | 2588 | |
5fe03e38 RS |
2589 | p = strchr(arg, ':'); |
2590 | if (p) { | |
815f98cc AJ |
2591 | x = strtol(arg, &end, 10); |
2592 | if (end == p) | |
2593 | y = strtol(end+1, &end, 10); | |
bb270c08 DB |
2594 | if (x > 0 && y > 0) |
2595 | ar = (double)x / (double)y; | |
5fe03e38 | 2596 | } else |
815f98cc | 2597 | ar = strtod(arg, NULL); |
5fe03e38 RS |
2598 | |
2599 | if (!ar) { | |
2600 | fprintf(stderr, "Incorrect aspect ratio specification.\n"); | |
296df4e7 | 2601 | av_exit(1); |
5fe03e38 RS |
2602 | } |
2603 | frame_aspect_ratio = ar; | |
2604 | } | |
2605 | ||
a5926d85 AJ |
2606 | static int opt_metadata(const char *opt, const char *arg) |
2607 | { | |
2608 | char *mid= strchr(arg, '='); | |
2609 | ||
2610 | if(!mid){ | |
2611 | fprintf(stderr, "Missing =\n"); | |
2612 | av_exit(1); | |
2613 | } | |
2614 | *mid++= 0; | |
2615 | ||
2616 | metadata_count++; | |
2617 | metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count); | |
2618 | metadata[metadata_count-1].key = av_strdup(arg); | |
2619 | metadata[metadata_count-1].value= av_strdup(mid); | |
2620 | ||
2621 | return 0; | |
2622 | } | |
2623 | ||
b29f97d1 | 2624 | static void opt_qscale(const char *arg) |
85f07f22 | 2625 | { |
158c7f05 | 2626 | video_qscale = atof(arg); |
4e64bead | 2627 | if (video_qscale <= 0 || |
158c7f05 | 2628 | video_qscale > 255) { |
4e64bead | 2629 | fprintf(stderr, "qscale must be > 0.0 and <= 255\n"); |
296df4e7 | 2630 | av_exit(1); |
85f07f22 FB |
2631 | } |
2632 | } | |
2633 | ||
bb198e19 MN |
2634 | static void opt_top_field_first(const char *arg) |
2635 | { | |
2636 | top_field_first= atoi(arg); | |
2637 | } | |
2638 | ||
d18811bb | 2639 | static int opt_thread_count(const char *opt, const char *arg) |
9c3d33d6 | 2640 | { |
d18811bb | 2641 | thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); |
b250f9c6 | 2642 | #if !HAVE_THREADS |
d8019eb5 AD |
2643 | if (verbose >= 0) |
2644 | fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n"); | |
842b556a | 2645 | #endif |
d18811bb | 2646 | return 0; |
9c3d33d6 MN |
2647 | } |
2648 | ||
ce1ee094 PR |
2649 | static void opt_audio_sample_fmt(const char *arg) |
2650 | { | |
2651 | if (strcmp(arg, "list")) | |
2652 | audio_sample_fmt = avcodec_get_sample_fmt(arg); | |
2653 | else { | |
2654 | list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB); | |
2655 | av_exit(0); | |
2656 | } | |
2657 | } | |
2658 | ||
c48da33c | 2659 | static int opt_audio_rate(const char *opt, const char *arg) |
85f07f22 | 2660 | { |
c48da33c SS |
2661 | audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); |
2662 | return 0; | |
85f07f22 FB |
2663 | } |
2664 | ||
c48da33c | 2665 | static int opt_audio_channels(const char *opt, const char *arg) |
85f07f22 | 2666 | { |
c48da33c SS |
2667 | audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); |
2668 | return 0; | |
85f07f22 FB |
2669 | } |
2670 | ||
b29f97d1 | 2671 | static void opt_video_channel(const char *arg) |
a5df11ab FB |
2672 | { |
2673 | video_channel = strtol(arg, NULL, 0); | |
2674 | } | |
2675 | ||
e3ee3283 AB |
2676 | static void opt_video_standard(const char *arg) |
2677 | { | |
2678 | video_standard = av_strdup(arg); | |
2679 | } | |
2680 | ||
4a897224 | 2681 | static void opt_codec(int *pstream_copy, char **pcodec_name, |
cf7fc795 | 2682 | int codec_type, const char *arg) |
85f07f22 | 2683 | { |
4a897224 | 2684 | av_freep(pcodec_name); |
1629626f | 2685 | if (!strcmp(arg, "copy")) { |
cf7fc795 | 2686 | *pstream_copy = 1; |
85f07f22 | 2687 | } else { |
4a897224 | 2688 | *pcodec_name = av_strdup(arg); |
85f07f22 FB |
2689 | } |
2690 | } | |
2691 | ||
cf7fc795 FB |
2692 | static void opt_audio_codec(const char *arg) |
2693 | { | |
4a897224 | 2694 | opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg); |
cf7fc795 FB |
2695 | } |
2696 | ||
b2a2197e MN |
2697 | static void opt_audio_tag(const char *arg) |
2698 | { | |
2699 | char *tail; | |
2700 | audio_codec_tag= strtol(arg, &tail, 0); | |
2701 | ||
2702 | if(!tail || *tail) | |
2703 | audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24); | |
2704 | } | |
2705 | ||
2706 | static void opt_video_tag(const char *arg) | |
2707 | { | |
2708 | char *tail; | |
2709 | video_codec_tag= strtol(arg, &tail, 0); | |
2710 | ||
2711 | if(!tail || *tail) | |
2712 | video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24); | |
2713 | } | |
2714 | ||
b29f97d1 | 2715 | static void opt_video_codec(const char *arg) |
85f07f22 | 2716 | { |
4a897224 | 2717 | opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg); |
cf7fc795 | 2718 | } |
85f07f22 | 2719 | |
cf7fc795 FB |
2720 | static void opt_subtitle_codec(const char *arg) |
2721 | { | |
4a897224 | 2722 | opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg); |
85f07f22 FB |
2723 | } |
2724 | ||
27ad7d3a BC |
2725 | static void opt_subtitle_tag(const char *arg) |
2726 | { | |
2727 | char *tail; | |
2728 | subtitle_codec_tag= strtol(arg, &tail, 0); | |
2729 | ||
2730 | if(!tail || *tail) | |
2731 | subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24); | |
2732 | } | |
2733 | ||
b29f97d1 | 2734 | static void opt_map(const char *arg) |
85f07f22 FB |
2735 | { |
2736 | AVStreamMap *m; | |
815f98cc | 2737 | char *p; |
85f07f22 | 2738 | |
85f07f22 FB |
2739 | m = &stream_maps[nb_stream_maps++]; |
2740 | ||
815f98cc | 2741 | m->file_index = strtol(arg, &p, 0); |
85f07f22 FB |
2742 | if (*p) |
2743 | p++; | |
a5dc85ef | 2744 | |
815f98cc | 2745 | m->stream_index = strtol(p, &p, 0); |
b4a3389e WG |
2746 | if (*p) { |
2747 | p++; | |
815f98cc | 2748 | m->sync_file_index = strtol(p, &p, 0); |
b4a3389e WG |
2749 | if (*p) |
2750 | p++; | |
815f98cc | 2751 | m->sync_stream_index = strtol(p, &p, 0); |
b4a3389e WG |
2752 | } else { |
2753 | m->sync_file_index = m->file_index; | |
2754 | m->sync_stream_index = m->stream_index; | |
2755 | } | |
85f07f22 FB |
2756 | } |
2757 | ||
0a38bafd PB |
2758 | static void opt_map_meta_data(const char *arg) |
2759 | { | |
2760 | AVMetaDataMap *m; | |
815f98cc | 2761 | char *p; |
115329f1 | 2762 | |
0a38bafd PB |
2763 | m = &meta_data_maps[nb_meta_data_maps++]; |
2764 | ||
815f98cc | 2765 | m->out_file = strtol(arg, &p, 0); |
0a38bafd PB |
2766 | if (*p) |
2767 | p++; | |
2768 | ||
815f98cc | 2769 | m->in_file = strtol(p, &p, 0); |
0a38bafd PB |
2770 | } |
2771 | ||
8833f375 MN |
2772 | static void opt_input_ts_scale(const char *arg) |
2773 | { | |
2774 | unsigned int stream; | |
2775 | double scale; | |
2776 | char *p; | |
2777 | ||
2778 | stream = strtol(arg, &p, 0); | |
2779 | if (*p) | |
2780 | p++; | |
2781 | scale= strtod(p, &p); | |
2782 | ||
2783 | if(stream >= MAX_STREAMS) | |
2784 | av_exit(1); | |
2785 | ||
2786 | input_files_ts_scale[nb_input_files][stream]= scale; | |
2787 | } | |
2788 | ||
b19221c8 | 2789 | static int opt_recording_time(const char *opt, const char *arg) |
85f07f22 | 2790 | { |
b19221c8 SS |
2791 | recording_time = parse_time_or_die(opt, arg, 1); |
2792 | return 0; | |
85f07f22 FB |
2793 | } |
2794 | ||
b19221c8 | 2795 | static int opt_start_time(const char *opt, const char *arg) |
8831db5c | 2796 | { |
b19221c8 SS |
2797 | start_time = parse_time_or_die(opt, arg, 1); |
2798 | return 0; | |
8831db5c MN |
2799 | } |
2800 | ||
b19221c8 | 2801 | static int opt_rec_timestamp(const char *opt, const char *arg) |
4568325a | 2802 | { |
b19221c8 SS |
2803 | rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000; |
2804 | return 0; | |
4568325a RS |
2805 | } |
2806 | ||
b19221c8 | 2807 | static int opt_input_ts_offset(const char *opt, const char *arg) |
a6a92a9a | 2808 | { |
b19221c8 SS |
2809 | input_ts_offset = parse_time_or_die(opt, arg, 1); |
2810 | return 0; | |
a6a92a9a WG |
2811 | } |
2812 | ||
4a897224 NG |
2813 | static enum CodecID find_codec_or_die(const char *name, int type, int encoder) |
2814 | { | |
f73008d8 | 2815 | const char *codec_string = encoder ? "encoder" : "decoder"; |
4a897224 NG |
2816 | AVCodec *codec; |
2817 | ||
2818 | if(!name) | |
2819 | return CODEC_ID_NONE; | |
2820 | codec = encoder ? | |
2821 | avcodec_find_encoder_by_name(name) : | |
2822 | avcodec_find_decoder_by_name(name); | |
2823 | if(!codec) { | |
49a06a4d | 2824 | fprintf(stderr, "Unknown %s '%s'\n", codec_string, name); |
296df4e7 | 2825 | av_exit(1); |
4a897224 NG |
2826 | } |
2827 | if(codec->type != type) { | |
49a06a4d | 2828 | fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name); |
296df4e7 | 2829 | av_exit(1); |
4a897224 NG |
2830 | } |
2831 | return codec->id; | |
2832 | } | |
2833 | ||
b29f97d1 | 2834 | static void opt_input_file(const char *filename) |
85f07f22 FB |
2835 | { |
2836 | AVFormatContext *ic; | |
2837 | AVFormatParameters params, *ap = ¶ms; | |
a5abfd8f | 2838 | AVInputFormat *file_iformat = NULL; |
14bea432 | 2839 | int err, i, ret, rfps, rfps_base; |
bd1b79a1 | 2840 | int64_t timestamp; |
85f07f22 | 2841 | |
a5abfd8f EB |
2842 | if (last_asked_format) { |
2843 | file_iformat = av_find_input_format(last_asked_format); | |
2844 | last_asked_format = NULL; | |
2845 | } | |
2846 | ||
b242baa4 FB |
2847 | if (!strcmp(filename, "-")) |
2848 | filename = "pipe:"; | |
2849 | ||
115329f1 | 2850 | using_stdin |= !strncmp(filename, "pipe:", 5) || |
9d58e0a9 | 2851 | !strcmp(filename, "/dev/stdin"); |
d9a916e2 | 2852 | |
85f07f22 | 2853 | /* get default parameters from command line */ |
8e2fd8e1 | 2854 | ic = avformat_alloc_context(); |
7ef61879 RP |
2855 | if (!ic) { |
2856 | print_error(filename, AVERROR(ENOMEM)); | |
2857 | av_exit(1); | |
2858 | } | |
4eb72c6b | 2859 | |
79fdaa4c | 2860 | memset(ap, 0, sizeof(*ap)); |
4eb72c6b | 2861 | ap->prealloced_context = 1; |
79fdaa4c FB |
2862 | ap->sample_rate = audio_sample_rate; |
2863 | ap->channels = audio_channels; | |
b33ece16 SS |
2864 | ap->time_base.den = frame_rate.num; |
2865 | ap->time_base.num = frame_rate.den; | |
1ff93ffc TK |
2866 | ap->width = frame_width + frame_padleft + frame_padright; |
2867 | ap->height = frame_height + frame_padtop + frame_padbottom; | |
63167088 | 2868 | ap->pix_fmt = frame_pix_fmt; |
a79db0f7 | 2869 | // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat |
2639c651 RS |
2870 | ap->channel = video_channel; |
2871 | ap->standard = video_standard; | |
4a897224 NG |
2872 | ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0); |
2873 | ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0); | |
5b6d5596 MN |
2874 | if(pgmyuv_compatibility_hack) |
2875 | ap->video_codec_id= CODEC_ID_PGMYUV; | |
79fdaa4c | 2876 | |
3022cd10 | 2877 | set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM); |
62600469 MN |
2878 | |
2879 | ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0); | |
2880 | ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0); | |
2881 | ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0); | |
1ad1eaad | 2882 | ic->flags |= AVFMT_FLAG_NONBLOCK; |
62600469 | 2883 | |
79fdaa4c FB |
2884 | /* open the input file with generic libav function */ |
2885 | err = av_open_input_file(&ic, filename, file_iformat, 0, ap); | |
85f07f22 | 2886 | if (err < 0) { |
79fdaa4c | 2887 | print_error(filename, err); |
296df4e7 | 2888 | av_exit(1); |
85f07f22 | 2889 | } |
50e143c4 NS |
2890 | if(opt_programid) { |
2891 | int i; | |
2892 | for(i=0; i<ic->nb_programs; i++) | |
2893 | if(ic->programs[i]->id != opt_programid) | |
2894 | ic->programs[i]->discard = AVDISCARD_ALL; | |
2895 | } | |
30bc6613 | 2896 | |
5894e1bb VP |
2897 | ic->loop_input = loop_input; |
2898 | ||
79fdaa4c FB |
2899 | /* If not enough info to get the stream parameters, we decode the |
2900 | first frames to get it. (used in mpeg case for example) */ | |
2901 | ret = av_find_stream_info(ic); | |
d8019eb5 | 2902 | if (ret < 0 && verbose >= 0) { |
85f07f22 | 2903 | fprintf(stderr, "%s: could not find codec parameters\n", filename); |
296df4e7 | 2904 | av_exit(1); |
85f07f22 FB |
2905 | } |
2906 | ||
bd1b79a1 MN |
2907 | timestamp = start_time; |
2908 | /* add the stream start time */ | |
2909 | if (ic->start_time != AV_NOPTS_VALUE) | |
2910 | timestamp += ic->start_time; | |
2911 | ||
254abc2e FB |
2912 | /* if seeking requested, we execute it */ |
2913 | if (start_time != 0) { | |
3ba1438d | 2914 | ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD); |
254abc2e | 2915 | if (ret < 0) { |
115329f1 | 2916 | fprintf(stderr, "%s: could not seek to position %0.3f\n", |
254abc2e FB |
2917 | filename, (double)timestamp / AV_TIME_BASE); |
2918 | } | |
2919 | /* reset seek info */ | |
2920 | start_time = 0; | |
2921 | } | |
2922 | ||
85f07f22 FB |
2923 | /* update the current parameters so that they match the one of the input stream */ |
2924 | for(i=0;i<ic->nb_streams;i++) { | |
22b16e6a MN |
2925 | AVStream *st = ic->streams[i]; |
2926 | AVCodecContext *enc = st->codec; | |
c62c07d3 MN |
2927 | if(thread_count>1) |
2928 | avcodec_thread_init(enc, thread_count); | |
c62c07d3 | 2929 | enc->thread_count= thread_count; |
85f07f22 FB |
2930 | switch(enc->codec_type) { |
2931 | case CODEC_TYPE_AUDIO: | |
636f1c4c | 2932 | set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM); |
e0d2714a | 2933 | //fprintf(stderr, "\nInput Audio channels: %d", enc->channels); |
13367a46 | 2934 | channel_layout = enc->channel_layout; |
85f07f22 FB |
2935 | audio_channels = enc->channels; |
2936 | audio_sample_rate = enc->sample_rate; | |
a79db0f7 | 2937 | audio_sample_fmt = enc->sample_fmt; |
6488cf9b | 2938 | input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name); |
b4aea108 | 2939 | if(audio_disable) |
22b16e6a | 2940 | st->discard= AVDISCARD_ALL; |
85f07f22 FB |
2941 | break; |
2942 | case CODEC_TYPE_VIDEO: | |
636f1c4c | 2943 | set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM); |
85f07f22 FB |
2944 | frame_height = enc->height; |
2945 | frame_width = enc->width; | |
c30a4489 AJ |
2946 | if(ic->streams[i]->sample_aspect_ratio.num) |
2947 | frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio); | |
2948 | else | |
2949 | frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio); | |
2950 | frame_aspect_ratio *= (float) enc->width / enc->height; | |
bb270c08 | 2951 | frame_pix_fmt = enc->pix_fmt; |
c0df9d75 MN |
2952 | rfps = ic->streams[i]->r_frame_rate.num; |
2953 | rfps_base = ic->streams[i]->r_frame_rate.den; | |
33946533 JM |
2954 | if(enc->lowres) { |
2955 | enc->flags |= CODEC_FLAG_EMU_EDGE; | |
2956 | frame_height >>= enc->lowres; | |
2957 | frame_width >>= enc->lowres; | |
2958 | } | |
f4f3223f MN |
2959 | if(me_threshold) |
2960 | enc->debug |= FF_DEBUG_MV; | |
d7425f59 | 2961 | |
115329f1 | 2962 | if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) { |
d8019eb5 AD |
2963 | |
2964 | if (verbose >= 0) | |
386c88de | 2965 | fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n", |
c0df9d75 | 2966 | i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num, |
d8019eb5 | 2967 | |
15bc38e5 | 2968 | (float)rfps / rfps_base, rfps, rfps_base); |
79fdaa4c | 2969 | } |
bf5af568 | 2970 | /* update the current frame rate to match the stream frame rate */ |
b33ece16 SS |
2971 | frame_rate.num = rfps; |
2972 | frame_rate.den = rfps_base; | |
bdfcbbed | 2973 | |
6488cf9b | 2974 | input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name); |
b4aea108 | 2975 | if(video_disable) |
22b16e6a | 2976 | st->discard= AVDISCARD_ALL; |
f3356e9c | 2977 | else if(video_discard) |
22b16e6a | 2978 | st->discard= video_discard; |
85f07f22 | 2979 | break; |
254abc2e FB |
2980 | case CODEC_TYPE_DATA: |
2981 | break; | |
cf7fc795 | 2982 | case CODEC_TYPE_SUBTITLE: |
6488cf9b | 2983 | input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name); |
11bf3847 | 2984 | if(subtitle_disable) |
22b16e6a | 2985 | st->discard = AVDISCARD_ALL; |
cf7fc795 | 2986 | break; |
f8d7c9d3 | 2987 | case CODEC_TYPE_ATTACHMENT: |
ae38261e | 2988 | case CODEC_TYPE_UNKNOWN: |
6488cf9b | 2989 | nb_icodecs++; |
ae38261e | 2990 | break; |
51bd4565 | 2991 | default: |
0f4e8165 | 2992 | abort(); |
85f07f22 FB |
2993 | } |
2994 | } | |
115329f1 | 2995 | |
85f07f22 | 2996 | input_files[nb_input_files] = ic; |
bd1b79a1 | 2997 | input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp); |
85f07f22 | 2998 | /* dump the file content */ |
d8019eb5 AD |
2999 | if (verbose >= 0) |
3000 | dump_format(ic, nb_input_files, filename, 0); | |
3001 | ||
85f07f22 | 3002 | nb_input_files++; |
bdfcbbed | 3003 | |
2639c651 | 3004 | video_channel = 0; |
115329f1 | 3005 | |
a06a18c5 BC |
3006 | av_freep(&video_codec_name); |
3007 | av_freep(&audio_codec_name); | |
3008 | av_freep(&subtitle_codec_name); | |
85f07f22 FB |
3009 | } |
3010 | ||
11bf3847 AJ |
3011 | static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr, |
3012 | int *has_subtitle_ptr) | |
919f448d | 3013 | { |
11bf3847 | 3014 | int has_video, has_audio, has_subtitle, i, j; |
919f448d FB |
3015 | AVFormatContext *ic; |
3016 | ||
3017 | has_video = 0; | |
3018 | has_audio = 0; | |
11bf3847 | 3019 | has_subtitle = 0; |
919f448d FB |
3020 | for(j=0;j<nb_input_files;j++) { |
3021 | ic = input_files[j]; | |
3022 | for(i=0;i<ic->nb_streams;i++) { | |
01f4895c | 3023 | AVCodecContext *enc = ic->streams[i]->codec; |
919f448d FB |
3024 | switch(enc->codec_type) { |
3025 | case CODEC_TYPE_AUDIO: | |
3026 | has_audio = 1; | |
3027 | break; | |
3028 | case CODEC_TYPE_VIDEO: | |
3029 | has_video = 1; | |
3030 | break; | |
11bf3847 AJ |
3031 | case CODEC_TYPE_SUBTITLE: |
3032 | has_subtitle = 1; | |
3033 | break; | |
6fb316d5 | 3034 | case CODEC_TYPE_DATA: |
f8d7c9d3 | 3035 | case CODEC_TYPE_ATTACHMENT: |
ae38261e | 3036 | case CODEC_TYPE_UNKNOWN: |
6fb316d5 | 3037 | break; |
51bd4565 | 3038 | default: |
0f4e8165 | 3039 | abort(); |
919f448d FB |
3040 | } |
3041 | } | |
3042 | } | |
3043 | *has_video_ptr = has_video; | |
3044 | *has_audio_ptr = has_audio; | |
11bf3847 | 3045 | *has_subtitle_ptr = has_subtitle; |
919f448d FB |
3046 | } |
3047 | ||
cf7fc795 | 3048 | static void new_video_stream(AVFormatContext *oc) |
85f07f22 FB |
3049 | { |
3050 | AVStream *st; | |
cf7fc795 | 3051 | AVCodecContext *video_enc; |
340e2303 | 3052 | enum CodecID codec_id; |
115329f1 | 3053 | |
cf7fc795 FB |
3054 | st = av_new_stream(oc, oc->nb_streams); |
3055 | if (!st) { | |
3056 | fprintf(stderr, "Could not alloc stream\n"); | |
296df4e7 | 3057 | av_exit(1); |
cf7fc795 | 3058 | } |
54cc9c46 | 3059 | avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO); |
748c2fca MN |
3060 | bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters; |
3061 | video_bitstream_filters= NULL; | |
3062 | ||
cf7fc795 | 3063 | if(thread_count>1) |
01f4895c | 3064 | avcodec_thread_init(st->codec, thread_count); |
115329f1 | 3065 | |
01f4895c | 3066 | video_enc = st->codec; |
115329f1 | 3067 | |
cf7fc795 FB |
3068 | if(video_codec_tag) |
3069 | video_enc->codec_tag= video_codec_tag; | |
115329f1 | 3070 | |
90ad92b3 | 3071 | if( (video_global_header&1) |
637b5326 | 3072 | || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){ |
cf7fc795 | 3073 | video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; |
636f1c4c | 3074 | avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER; |
637b5326 MN |
3075 | } |
3076 | if(video_global_header&2){ | |
90ad92b3 | 3077 | video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER; |
636f1c4c | 3078 | avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER; |
637b5326 | 3079 | } |
90ad92b3 | 3080 | |
cf7fc795 FB |
3081 | if (video_stream_copy) { |
3082 | st->stream_copy = 1; | |
3083 | video_enc->codec_type = CODEC_TYPE_VIDEO; | |
143df827 | 3084 | video_enc->sample_aspect_ratio = |
c30a4489 | 3085 | st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255); |
cf7fc795 | 3086 | } else { |
464a631c | 3087 | const char *p; |
cf7fc795 FB |
3088 | int i; |
3089 | AVCodec *codec; | |
9de0be61 | 3090 | AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1}; |
115329f1 | 3091 | |
6488cf9b | 3092 | if (video_codec_name) { |
4a897224 | 3093 | codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1); |
6488cf9b AJ |
3094 | codec = avcodec_find_encoder_by_name(video_codec_name); |
3095 | output_codecs[nb_ocodecs] = codec; | |
3096 | } else { | |
3097 | codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO); | |
3098 | codec = avcodec_find_encoder(codec_id); | |
3099 | } | |
115329f1 | 3100 | |
cf7fc795 | 3101 | video_enc->codec_id = codec_id; |
115329f1 | 3102 | |
636f1c4c | 3103 | set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); |
115329f1 | 3104 | |
d2845b75 SS |
3105 | if (codec && codec->supported_framerates && !force_fps) |
3106 | fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)]; | |
9de0be61 MN |
3107 | video_enc->time_base.den = fps.num; |
3108 | video_enc->time_base.num = fps.den; | |
115329f1 | 3109 | |
cf7fc795 FB |
3110 | video_enc->width = frame_width + frame_padright + frame_padleft; |
3111 | video_enc->height = frame_height + frame_padtop + frame_padbottom; | |
e7268d51 | 3112 | video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255); |
cf7fc795 | 3113 | video_enc->pix_fmt = frame_pix_fmt; |
c30a4489 | 3114 | st->sample_aspect_ratio = video_enc->sample_aspect_ratio; |
cf7fc795 FB |
3115 | |
3116 | if(codec && codec->pix_fmts){ | |
3117 | const enum PixelFormat *p= codec->pix_fmts; | |
3118 | for(; *p!=-1; p++){ | |
3119 | if(*p == video_enc->pix_fmt) | |
3120 | break; | |
3121 | } | |
3122 | if(*p == -1) | |
3123 | video_enc->pix_fmt = codec->pix_fmts[0]; | |
3124 | } | |
3125 | ||
babe0e8c | 3126 | if (intra_only) |
cf7fc795 FB |
3127 | video_enc->gop_size = 0; |
3128 | if (video_qscale || same_quality) { | |
3129 | video_enc->flags |= CODEC_FLAG_QSCALE; | |
115329f1 | 3130 | video_enc->global_quality= |
cf7fc795 FB |
3131 | st->quality = FF_QP2LAMBDA * video_qscale; |
3132 | } | |
3133 | ||
3134 | if(intra_matrix) | |
3135 | video_enc->intra_matrix = intra_matrix; | |
3136 | if(inter_matrix) | |
3137 | video_enc->inter_matrix = inter_matrix; | |
3138 | ||
cf7fc795 FB |
3139 | video_enc->thread_count = thread_count; |
3140 | p= video_rc_override_string; | |
3141 | for(i=0; p; i++){ | |
3142 | int start, end, q; | |
3143 | int e=sscanf(p, "%d,%d,%d", &start, &end, &q); | |
3144 | if(e!=3){ | |
3145 | fprintf(stderr, "error parsing rc_override\n"); | |
296df4e7 | 3146 | av_exit(1); |
cf7fc795 | 3147 | } |
115329f1 DB |
3148 | video_enc->rc_override= |
3149 | av_realloc(video_enc->rc_override, | |
cf7fc795 FB |
3150 | sizeof(RcOverride)*(i+1)); |
3151 | video_enc->rc_override[i].start_frame= start; | |
3152 | video_enc->rc_override[i].end_frame = end; | |
3153 | if(q>0){ | |
3154 | video_enc->rc_override[i].qscale= q; | |
3155 | video_enc->rc_override[i].quality_factor= 1.0; | |
3156 | } | |
3157 | else{ | |
3158 | video_enc->rc_override[i].qscale= 0; | |
3159 | video_enc->rc_override[i].quality_factor= -q/100.0; | |
3160 | } | |
3161 | p= strchr(p, '/'); | |
3162 | if(p) p++; | |
3163 | } | |
3164 | video_enc->rc_override_count=i; | |
079e8cb9 BC |
3165 | if (!video_enc->rc_initial_buffer_occupancy) |
3166 | video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4; | |
cf7fc795 | 3167 | video_enc->me_threshold= me_threshold; |
cf7fc795 | 3168 | video_enc->intra_dc_precision= intra_dc_precision - 8; |
cf7fc795 | 3169 | |
cf7fc795 FB |
3170 | if (do_psnr) |
3171 | video_enc->flags|= CODEC_FLAG_PSNR; | |
115329f1 | 3172 | |
cf7fc795 FB |
3173 | /* two pass mode */ |
3174 | if (do_pass) { | |
3175 | if (do_pass == 1) { | |
3176 | video_enc->flags |= CODEC_FLAG_PASS1; | |
3177 | } else { | |
3178 | video_enc->flags |= CODEC_FLAG_PASS2; | |
3179 | } | |
3180 | } | |
3181 | } | |
6488cf9b | 3182 | nb_ocodecs++; |
0fc2c0f6 MC |
3183 | if (video_language) { |
3184 | av_metadata_set(&st->metadata, "language", video_language); | |
3185 | av_freep(&video_language); | |
3186 | } | |
cf7fc795 FB |
3187 | |
3188 | /* reset some key parameters */ | |
3189 | video_disable = 0; | |
4a897224 | 3190 | av_freep(&video_codec_name); |