GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg.c Lines: 2028 2768 73.3 %
Date: 2020-04-02 13:49:07 Branches: 1490 2165 68.8 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2000-2003 Fabrice Bellard
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
/**
22
 * @file
23
 * multimedia converter based on the FFmpeg libraries
24
 */
25
26
#include "config.h"
27
#include <ctype.h>
28
#include <string.h>
29
#include <math.h>
30
#include <stdlib.h>
31
#include <errno.h>
32
#include <limits.h>
33
#include <stdatomic.h>
34
#include <stdint.h>
35
36
#if HAVE_IO_H
37
#include <io.h>
38
#endif
39
#if HAVE_UNISTD_H
40
#include <unistd.h>
41
#endif
42
43
#include "libavformat/avformat.h"
44
#include "libavdevice/avdevice.h"
45
#include "libswresample/swresample.h"
46
#include "libavutil/opt.h"
47
#include "libavutil/channel_layout.h"
48
#include "libavutil/parseutils.h"
49
#include "libavutil/samplefmt.h"
50
#include "libavutil/fifo.h"
51
#include "libavutil/hwcontext.h"
52
#include "libavutil/internal.h"
53
#include "libavutil/intreadwrite.h"
54
#include "libavutil/dict.h"
55
#include "libavutil/display.h"
56
#include "libavutil/mathematics.h"
57
#include "libavutil/pixdesc.h"
58
#include "libavutil/avstring.h"
59
#include "libavutil/libm.h"
60
#include "libavutil/imgutils.h"
61
#include "libavutil/timestamp.h"
62
#include "libavutil/bprint.h"
63
#include "libavutil/time.h"
64
#include "libavutil/thread.h"
65
#include "libavutil/threadmessage.h"
66
#include "libavcodec/mathops.h"
67
#include "libavformat/os_support.h"
68
69
# include "libavfilter/avfilter.h"
70
# include "libavfilter/buffersrc.h"
71
# include "libavfilter/buffersink.h"
72
73
#if HAVE_SYS_RESOURCE_H
74
#include <sys/time.h>
75
#include <sys/types.h>
76
#include <sys/resource.h>
77
#elif HAVE_GETPROCESSTIMES
78
#include <windows.h>
79
#endif
80
#if HAVE_GETPROCESSMEMORYINFO
81
#include <windows.h>
82
#include <psapi.h>
83
#endif
84
#if HAVE_SETCONSOLECTRLHANDLER
85
#include <windows.h>
86
#endif
87
88
89
#if HAVE_SYS_SELECT_H
90
#include <sys/select.h>
91
#endif
92
93
#if HAVE_TERMIOS_H
94
#include <fcntl.h>
95
#include <sys/ioctl.h>
96
#include <sys/time.h>
97
#include <termios.h>
98
#elif HAVE_KBHIT
99
#include <conio.h>
100
#endif
101
102
#include <time.h>
103
104
#include "ffmpeg.h"
105
#include "cmdutils.h"
106
107
#include "libavutil/avassert.h"
108
109
const char program_name[] = "ffmpeg";
110
const int program_birth_year = 2000;
111
112
static FILE *vstats_file;
113
114
const char *const forced_keyframes_const_names[] = {
115
    "n",
116
    "n_forced",
117
    "prev_forced_n",
118
    "prev_forced_t",
119
    "t",
120
    NULL
121
};
122
123
typedef struct BenchmarkTimeStamps {
124
    int64_t real_usec;
125
    int64_t user_usec;
126
    int64_t sys_usec;
127
} BenchmarkTimeStamps;
128
129
static void do_video_stats(OutputStream *ost, int frame_size);
130
static BenchmarkTimeStamps get_benchmark_time_stamps(void);
131
static int64_t getmaxrss(void);
132
static int ifilter_has_all_input_formats(FilterGraph *fg);
133
134
static int run_as_daemon  = 0;
135
static int nb_frames_dup = 0;
136
static unsigned dup_warning = 1000;
137
static int nb_frames_drop = 0;
138
static int64_t decode_error_stat[2];
139
140
static int want_sdp = 1;
141
142
static BenchmarkTimeStamps current_time;
143
AVIOContext *progress_avio = NULL;
144
145
static uint8_t *subtitle_out;
146
147
InputStream **input_streams = NULL;
148
int        nb_input_streams = 0;
149
InputFile   **input_files   = NULL;
150
int        nb_input_files   = 0;
151
152
OutputStream **output_streams = NULL;
153
int         nb_output_streams = 0;
154
OutputFile   **output_files   = NULL;
155
int         nb_output_files   = 0;
156
157
FilterGraph **filtergraphs;
158
int        nb_filtergraphs;
159
160
#if HAVE_TERMIOS_H
161
162
/* init terminal so that we can grab keys */
163
static struct termios oldtty;
164
static int restore_tty;
165
#endif
166
167
#if HAVE_THREADS
168
static void free_input_threads(void);
169
#endif
170
171
/* sub2video hack:
172
   Convert subtitles to video with alpha to insert them in filter graphs.
173
   This is a temporary solution until libavfilter gets real subtitles support.
174
 */
175
176
180
static int sub2video_get_blank_frame(InputStream *ist)
177
{
178
    int ret;
179
180
    AVFrame *frame = ist->sub2video.frame;
180
181
180
    av_frame_unref(frame);
182
180
    ist->sub2video.frame->width  = ist->dec_ctx->width  ? ist->dec_ctx->width  : ist->sub2video.w;
183
180
    ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
184
180
    ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
185
180
    if ((ret = av_frame_get_buffer(frame, 32)) < 0)
186
        return ret;
187
180
    memset(frame->data[0], 0, frame->height * frame->linesize[0]);
188
180
    return 0;
189
}
190
191
89
static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
192
                                AVSubtitleRect *r)
193
{
194
    uint32_t *pal, *dst2;
195
    uint8_t *src, *src2;
196
    int x, y;
197
198
89
    if (r->type != SUBTITLE_BITMAP) {
199
        av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
200
        return;
201
    }
202


89
    if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {
203
        av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle (%d %d %d %d) overflowing %d %d\n",
204
            r->x, r->y, r->w, r->h, w, h
205
        );
206
        return;
207
    }
208
209
89
    dst += r->y * dst_linesize + r->x * 4;
210
89
    src = r->data[0];
211
89
    pal = (uint32_t *)r->data[1];
212
3380
    for (y = 0; y < r->h; y++) {
213
3291
        dst2 = (uint32_t *)dst;
214
3291
        src2 = src;
215
1039366
        for (x = 0; x < r->w; x++)
216
1036075
            *(dst2++) = pal[*(src2++)];
217
3291
        dst += dst_linesize;
218
3291
        src += r->linesize[0];
219
    }
220
}
221
222
429
static void sub2video_push_ref(InputStream *ist, int64_t pts)
223
{
224
429
    AVFrame *frame = ist->sub2video.frame;
225
    int i;
226
    int ret;
227
228
    av_assert1(frame->data[0]);
229
429
    ist->sub2video.last_pts = frame->pts = pts;
230
858
    for (i = 0; i < ist->nb_filters; i++) {
231
429
        ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
232
                                           AV_BUFFERSRC_FLAG_KEEP_REF |
233
                                           AV_BUFFERSRC_FLAG_PUSH);
234

429
        if (ret != AVERROR_EOF && ret < 0)
235
            av_log(NULL, AV_LOG_WARNING, "Error while add the frame to buffer source(%s).\n",
236
                   av_err2str(ret));
237
    }
238
429
}
239
240
209
void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub)
241
{
242
209
    AVFrame *frame = ist->sub2video.frame;
243
    int8_t *dst;
244
    int     dst_linesize;
245
    int num_rects, i;
246
    int64_t pts, end_pts;
247
248
209
    if (!frame)
249
29
        return;
250
180
    if (sub) {
251
88
        pts       = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
252
88
                                 AV_TIME_BASE_Q, ist->st->time_base);
253
88
        end_pts   = av_rescale_q(sub->pts + sub->end_display_time   * 1000LL,
254
88
                                 AV_TIME_BASE_Q, ist->st->time_base);
255
88
        num_rects = sub->num_rects;
256
    } else {
257
        /* If we are initializing the system, utilize current heartbeat
258
           PTS as the start time, and show until the following subpicture
259
           is received. Otherwise, utilize the previous subpicture's end time
260
           as the fall-back value. */
261
184
        pts       = ist->sub2video.initialize ?
262
92
                    heartbeat_pts : ist->sub2video.end_pts;
263
92
        end_pts   = INT64_MAX;
264
92
        num_rects = 0;
265
    }
266
180
    if (sub2video_get_blank_frame(ist) < 0) {
267
        av_log(ist->dec_ctx, AV_LOG_ERROR,
268
               "Impossible to get a blank canvas.\n");
269
        return;
270
    }
271
180
    dst          = frame->data    [0];
272
180
    dst_linesize = frame->linesize[0];
273
269
    for (i = 0; i < num_rects; i++)
274
89
        sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
275
180
    sub2video_push_ref(ist, pts);
276
180
    ist->sub2video.end_pts = end_pts;
277
180
    ist->sub2video.initialize = 0;
278
}
279
280
425550
static void sub2video_heartbeat(InputStream *ist, int64_t pts)
281
{
282
425550
    InputFile *infile = input_files[ist->file_index];
283
    int i, j, nb_reqs;
284
    int64_t pts2;
285
286
    /* When a frame is read from a file, examine all sub2video streams in
287
       the same file and send the sub2video frame again. Otherwise, decoded
288
       video frames could be accumulating in the filter graph while a filter
289
       (possibly overlay) is desperately waiting for a subtitle frame. */
290
889863
    for (i = 0; i < infile->nb_streams; i++) {
291
464313
        InputStream *ist2 = input_streams[infile->ist_index + i];
292
464313
        if (!ist2->sub2video.frame)
293
463368
            continue;
294
        /* subtitles seem to be usually muxed ahead of other streams;
295
           if not, subtracting a larger time here is necessary */
296
945
        pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
297
        /* do not send the heartbeat frame if the subtitle is already ahead */
298
945
        if (pts2 <= ist2->sub2video.last_pts)
299
8
            continue;
300

937
        if (pts2 >= ist2->sub2video.end_pts || ist2->sub2video.initialize)
301
            /* if we have hit the end of the current displayed subpicture,
302
               or if we need to initialize the system, update the
303
               overlayed subpicture and its start/end times */
304
88
            sub2video_update(ist2, pts2 + 1, NULL);
305
1874
        for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
306
937
            nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
307
937
        if (nb_reqs)
308
249
            sub2video_push_ref(ist2, pts2);
309
    }
310
425550
}
311
312
33
static void sub2video_flush(InputStream *ist)
313
{
314
    int i;
315
    int ret;
316
317
33
    if (ist->sub2video.end_pts < INT64_MAX)
318
33
        sub2video_update(ist, INT64_MAX, NULL);
319
37
    for (i = 0; i < ist->nb_filters; i++) {
320
4
        ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
321

4
        if (ret != AVERROR_EOF && ret < 0)
322
            av_log(NULL, AV_LOG_WARNING, "Flush the frame error.\n");
323
    }
324
33
}
325
326
/* end of sub2video hack */
327
328
11742
static void term_exit_sigsafe(void)
329
{
330
#if HAVE_TERMIOS_H
331
11742
    if(restore_tty)
332
4
        tcsetattr (0, TCSANOW, &oldtty);
333
#endif
334
11742
}
335
336
11742
void term_exit(void)
337
{
338
11742
    av_log(NULL, AV_LOG_QUIET, "%s", "");
339
11742
    term_exit_sigsafe();
340
11742
}
341
342
static volatile int received_sigterm = 0;
343
static volatile int received_nb_signals = 0;
344
static atomic_int transcode_init_done = ATOMIC_VAR_INIT(0);
345
static volatile int ffmpeg_exited = 0;
346
static int main_return_code = 0;
347
348
static void
349
sigterm_handler(int sig)
350
{
351
    int ret;
352
    received_sigterm = sig;
353
    received_nb_signals++;
354
    term_exit_sigsafe();
355
    if(received_nb_signals > 3) {
356
        ret = write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
357
                    strlen("Received > 3 system signals, hard exiting\n"));
358
        if (ret < 0) { /* Do nothing */ };
359
        exit(123);
360
    }
361
}
362
363
#if HAVE_SETCONSOLECTRLHANDLER
364
static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
365
{
366
    av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
367
368
    switch (fdwCtrlType)
369
    {
370
    case CTRL_C_EVENT:
371
    case CTRL_BREAK_EVENT:
372
        sigterm_handler(SIGINT);
373
        return TRUE;
374
375
    case CTRL_CLOSE_EVENT:
376
    case CTRL_LOGOFF_EVENT:
377
    case CTRL_SHUTDOWN_EVENT:
378
        sigterm_handler(SIGTERM);
379
        /* Basically, with these 3 events, when we return from this method the
380
           process is hard terminated, so stall as long as we need to
381
           to try and let the main thread(s) clean up and gracefully terminate
382
           (we have at most 5 seconds, but should be done far before that). */
383
        while (!ffmpeg_exited) {
384
            Sleep(0);
385
        }
386
        return TRUE;
387
388
    default:
389
        av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
390
        return FALSE;
391
    }
392
}
393
#endif
394
395
5871
void term_init(void)
396
{
397
#if HAVE_TERMIOS_H
398

5871
    if (!run_as_daemon && stdin_interaction) {
399
        struct termios tty;
400
23
        if (tcgetattr (0, &tty) == 0) {
401
2
            oldtty = tty;
402
2
            restore_tty = 1;
403
404
2
            tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
405
                             |INLCR|IGNCR|ICRNL|IXON);
406
2
            tty.c_oflag |= OPOST;
407
2
            tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
408
2
            tty.c_cflag &= ~(CSIZE|PARENB);
409
2
            tty.c_cflag |= CS8;
410
2
            tty.c_cc[VMIN] = 1;
411
2
            tty.c_cc[VTIME] = 0;
412
413
2
            tcsetattr (0, TCSANOW, &tty);
414
        }
415
23
        signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
416
    }
417
#endif
418
419
5871
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
420
5871
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
421
#ifdef SIGXCPU
422
5871
    signal(SIGXCPU, sigterm_handler);
423
#endif
424
#ifdef SIGPIPE
425
5871
    signal(SIGPIPE, SIG_IGN); /* Broken pipe (POSIX). */
426
#endif
427
#if HAVE_SETCONSOLECTRLHANDLER
428
    SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
429
#endif
430
5871
}
431
432
/* read a key without blocking */
433
173
static int read_key(void)
434
{
435
    unsigned char ch;
436
#if HAVE_TERMIOS_H
437
173
    int n = 1;
438
    struct timeval tv;
439
    fd_set rfds;
440
441
173
    FD_ZERO(&rfds);
442
173
    FD_SET(0, &rfds);
443
173
    tv.tv_sec = 0;
444
173
    tv.tv_usec = 0;
445
173
    n = select(1, &rfds, NULL, NULL, &tv);
446
173
    if (n > 0) {
447
162
        n = read(0, &ch, 1);
448
162
        if (n == 1)
449
            return ch;
450
451
162
        return n;
452
    }
453
#elif HAVE_KBHIT
454
#    if HAVE_PEEKNAMEDPIPE
455
    static int is_pipe;
456
    static HANDLE input_handle;
457
    DWORD dw, nchars;
458
    if(!input_handle){
459
        input_handle = GetStdHandle(STD_INPUT_HANDLE);
460
        is_pipe = !GetConsoleMode(input_handle, &dw);
461
    }
462
463
    if (is_pipe) {
464
        /* When running under a GUI, you will end here. */
465
        if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
466
            // input pipe may have been closed by the program that ran ffmpeg
467
            return -1;
468
        }
469
        //Read it
470
        if(nchars != 0) {
471
            read(0, &ch, 1);
472
            return ch;
473
        }else{
474
            return -1;
475
        }
476
    }
477
#    endif
478
    if(kbhit())
479
        return(getch());
480
#endif
481
11
    return -1;
482
}
483
484
580809
static int decode_interrupt_cb(void *ctx)
485
{
486
580809
    return received_nb_signals > atomic_load(&transcode_init_done);
487
}
488
489
const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
490
491
5872
static void ffmpeg_cleanup(int ret)
492
{
493
    int i, j;
494
495
5872
    if (do_benchmark) {
496
        int maxrss = getmaxrss() / 1024;
497
        av_log(NULL, AV_LOG_INFO, "bench: maxrss=%ikB\n", maxrss);
498
    }
499
500
11562
    for (i = 0; i < nb_filtergraphs; i++) {
501
5690
        FilterGraph *fg = filtergraphs[i];
502
5690
        avfilter_graph_free(&fg->graph);
503
11364
        for (j = 0; j < fg->nb_inputs; j++) {
504
5674
            while (av_fifo_size(fg->inputs[j]->frame_queue)) {
505
                AVFrame *frame;
506
                av_fifo_generic_read(fg->inputs[j]->frame_queue, &frame,
507
                                     sizeof(frame), NULL);
508
                av_frame_free(&frame);
509
            }
510
5674
            av_fifo_freep(&fg->inputs[j]->frame_queue);
511
5674
            if (fg->inputs[j]->ist->sub2video.sub_queue) {
512
                while (av_fifo_size(fg->inputs[j]->ist->sub2video.sub_queue)) {
513
                    AVSubtitle sub;
514
                    av_fifo_generic_read(fg->inputs[j]->ist->sub2video.sub_queue,
515
                                         &sub, sizeof(sub), NULL);
516
                    avsubtitle_free(&sub);
517
                }
518
                av_fifo_freep(&fg->inputs[j]->ist->sub2video.sub_queue);
519
            }
520
5674
            av_buffer_unref(&fg->inputs[j]->hw_frames_ctx);
521
5674
            av_freep(&fg->inputs[j]->name);
522
5674
            av_freep(&fg->inputs[j]);
523
        }
524
5690
        av_freep(&fg->inputs);
525
11383
        for (j = 0; j < fg->nb_outputs; j++) {
526
5693
            av_freep(&fg->outputs[j]->name);
527
5693
            av_freep(&fg->outputs[j]->formats);
528
5693
            av_freep(&fg->outputs[j]->channel_layouts);
529
5693
            av_freep(&fg->outputs[j]->sample_rates);
530
5693
            av_freep(&fg->outputs[j]);
531
        }
532
5690
        av_freep(&fg->outputs);
533
5690
        av_freep(&fg->graph_desc);
534
535
5690
        av_freep(&filtergraphs[i]);
536
    }
537
5872
    av_freep(&filtergraphs);
538
539
5872
    av_freep(&subtitle_out);
540
541
    /* close files */
542
11743
    for (i = 0; i < nb_output_files; i++) {
543
5871
        OutputFile *of = output_files[i];
544
        AVFormatContext *s;
545
5871
        if (!of)
546
            continue;
547
5871
        s = of->ctx;
548

5871
        if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))
549
5818
            avio_closep(&s->pb);
550
5871
        avformat_free_context(s);
551
5871
        av_dict_free(&of->opts);
552
553
5871
        av_freep(&output_files[i]);
554
    }
555
11886
    for (i = 0; i < nb_output_streams; i++) {
556
6014
        OutputStream *ost = output_streams[i];
557
558
6014
        if (!ost)
559
            continue;
560
561
6098
        for (j = 0; j < ost->nb_bitstream_filters; j++)
562
84
            av_bsf_free(&ost->bsf_ctx[j]);
563
6014
        av_freep(&ost->bsf_ctx);
564
565
6014
        av_frame_free(&ost->filtered_frame);
566
6014
        av_frame_free(&ost->last_frame);
567
6014
        av_dict_free(&ost->encoder_opts);
568
569
6014
        av_freep(&ost->forced_keyframes);
570
6014
        av_expr_free(ost->forced_keyframes_pexpr);
571
6014
        av_freep(&ost->avfilter);
572
6014
        av_freep(&ost->logfile_prefix);
573
574
6014
        av_freep(&ost->audio_channels_map);
575
6014
        ost->audio_channels_mapped = 0;
576
577
6014
        av_dict_free(&ost->sws_dict);
578
6014
        av_dict_free(&ost->swr_opts);
579
580
6014
        avcodec_free_context(&ost->enc_ctx);
581
6014
        avcodec_parameters_free(&ost->ref_par);
582
583
6014
        if (ost->muxing_queue) {
584
6014
            while (av_fifo_size(ost->muxing_queue)) {
585
                AVPacket pkt;
586
                av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
587
                av_packet_unref(&pkt);
588
            }
589
6014
            av_fifo_freep(&ost->muxing_queue);
590
        }
591
592
6014
        av_freep(&output_streams[i]);
593
    }
594
#if HAVE_THREADS
595
5872
    free_input_threads();
596
#endif
597
11774
    for (i = 0; i < nb_input_files; i++) {
598
5902
        avformat_close_input(&input_files[i]->ctx);
599
5902
        av_freep(&input_files[i]);
600
    }
601
12092
    for (i = 0; i < nb_input_streams; i++) {
602
6220
        InputStream *ist = input_streams[i];
603
604
6220
        av_frame_free(&ist->decoded_frame);
605
6220
        av_frame_free(&ist->filter_frame);
606
6220
        av_dict_free(&ist->decoder_opts);
607
6220
        avsubtitle_free(&ist->prev_sub.subtitle);
608
6220
        av_frame_free(&ist->sub2video.frame);
609
6220
        av_freep(&ist->filters);
610
6220
        av_freep(&ist->hwaccel_device);
611
6220
        av_freep(&ist->dts_buffer);
612
613
6220
        avcodec_free_context(&ist->dec_ctx);
614
615
6220
        av_freep(&input_streams[i]);
616
    }
617
618
5872
    if (vstats_file) {
619
        if (fclose(vstats_file))
620
            av_log(NULL, AV_LOG_ERROR,
621
                   "Error closing vstats file, loss of information possible: %s\n",
622
                   av_err2str(AVERROR(errno)));
623
    }
624
5872
    av_freep(&vstats_filename);
625
626
5872
    av_freep(&input_streams);
627
5872
    av_freep(&input_files);
628
5872
    av_freep(&output_streams);
629
5872
    av_freep(&output_files);
630
631
5872
    uninit_opts();
632
633
5872
    avformat_network_deinit();
634
635
5872
    if (received_sigterm) {
636
        av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
637
               (int) received_sigterm);
638

5872
    } else if (ret && atomic_load(&transcode_init_done)) {
639
1
        av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
640
    }
641
5872
    term_exit();
642
5872
    ffmpeg_exited = 1;
643
5872
}
644
645
5902
void remove_avoptions(AVDictionary **a, AVDictionary *b)
646
{
647
5902
    AVDictionaryEntry *t = NULL;
648
649
24515
    while ((t = av_dict_get(b, "", t, AV_DICT_IGNORE_SUFFIX))) {
650
18613
        av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
651
    }
652
5902
}
653
654
17327
void assert_avoptions(AVDictionary *m)
655
{
656
    AVDictionaryEntry *t;
657
17327
    if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
658
        av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
659
        exit_program(1);
660
    }
661
17327
}
662
663
static void abort_codec_experimental(AVCodec *c, int encoder)
664
{
665
    exit_program(1);
666
}
667
668
2583739
static void update_benchmark(const char *fmt, ...)
669
{
670
2583739
    if (do_benchmark_all) {
671
        BenchmarkTimeStamps t = get_benchmark_time_stamps();
672
        va_list va;
673
        char buf[1024];
674
675
        if (fmt) {
676
            va_start(va, fmt);
677
            vsnprintf(buf, sizeof(buf), fmt, va);
678
            va_end(va);
679
            av_log(NULL, AV_LOG_INFO,
680
                   "bench: %8" PRIu64 " user %8" PRIu64 " sys %8" PRIu64 " real %s \n",
681
                   t.user_usec - current_time.user_usec,
682
                   t.sys_usec - current_time.sys_usec,
683
                   t.real_usec - current_time.real_usec, buf);
684
        }
685
        current_time = t;
686
    }
687
2583739
}
688
689
1
static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream, OSTFinished others)
690
{
691
    int i;
692
3
    for (i = 0; i < nb_output_streams; i++) {
693
2
        OutputStream *ost2 = output_streams[i];
694
2
        ost2->finished |= ost == ost2 ? this_stream : others;
695
    }
696
1
}
697
698
453695
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
699
{
700
453695
    AVFormatContext *s = of->ctx;
701
453695
    AVStream *st = ost->st;
702
    int ret;
703
704
    /*
705
     * Audio encoders may split the packets --  #frames in != #packets out.
706
     * But there is no reordering, so we can limit the number of output packets
707
     * by simply dropping them here.
708
     * Counting encoded video frames needs to be done separately because of
709
     * reordering, see do_video_out().
710
     * Do not count the packet when unqueued because it has been counted when queued.
711
     */
712

453695
    if (!(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && ost->encoding_needed) && !unqueue) {
713
354266
        if (ost->frame_number >= ost->max_frames) {
714
313
            av_packet_unref(pkt);
715
313
            return;
716
        }
717
353953
        ost->frame_number++;
718
    }
719
720
453382
    if (!of->header_written) {
721
277
        AVPacket tmp_pkt = {0};
722
        /* the muxer is not initialized yet, buffer the packet */
723
277
        if (!av_fifo_space(ost->muxing_queue)) {
724
16
            int new_size = FFMIN(2 * av_fifo_size(ost->muxing_queue),
725
                                 ost->max_muxing_queue_size);
726
16
            if (new_size <= av_fifo_size(ost->muxing_queue)) {
727
                av_log(NULL, AV_LOG_ERROR,
728
                       "Too many packets buffered for output stream %d:%d.\n",
729
                       ost->file_index, ost->st->index);
730
                exit_program(1);
731
            }
732
16
            ret = av_fifo_realloc2(ost->muxing_queue, new_size);
733
16
            if (ret < 0)
734
                exit_program(1);
735
        }
736
277
        ret = av_packet_make_refcounted(pkt);
737
277
        if (ret < 0)
738
            exit_program(1);
739
277
        av_packet_move_ref(&tmp_pkt, pkt);
740
277
        av_fifo_generic_write(ost->muxing_queue, &tmp_pkt, sizeof(tmp_pkt), NULL);
741
277
        return;
742
    }
743
744

453105
    if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
745

429777
        (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
746
23328
        pkt->pts = pkt->dts = AV_NOPTS_VALUE;
747
748
453105
    if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
749
        int i;
750
109082
        uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
751
                                              NULL);
752
109082
        ost->quality = sd ? AV_RL32(sd) : -1;
753
109082
        ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
754
755
545410
        for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
756

436328
            if (sd && i < sd[5])
757
                ost->error[i] = AV_RL64(sd + 8 + 8*i);
758
            else
759
436328
                ost->error[i] = -1;
760
        }
761
762

109082
        if (ost->frame_rate.num && ost->is_cfr) {
763
9789
            if (pkt->duration > 0)
764
                av_log(NULL, AV_LOG_WARNING, "Overriding packet duration by frame rate, this should not happen\n");
765
9789
            pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
766
                                         ost->mux_timebase);
767
        }
768
    }
769
770
453105
    av_packet_rescale_ts(pkt, ost->mux_timebase, ost->st->time_base);
771
772
453105
    if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
773
190547
        if (pkt->dts != AV_NOPTS_VALUE &&
774
167219
            pkt->pts != AV_NOPTS_VALUE &&
775
166252
            pkt->dts > pkt->pts) {
776
            av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
777
                   pkt->dts, pkt->pts,
778
                   ost->file_index, ost->st->index);
779
            pkt->pts =
780
            pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1
781
                     - FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)
782
                     - FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);
783
        }
784

190547
        if ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO || st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) &&
785
190534
            pkt->dts != AV_NOPTS_VALUE &&
786

167206
            !(st->codecpar->codec_id == AV_CODEC_ID_VP9 && ost->stream_copy) &&
787
166973
            ost->last_mux_dts != AV_NOPTS_VALUE) {
788
162555
            int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
789
162555
            if (pkt->dts < max) {
790
                int loglevel = max - pkt->dts > 2 || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
791
                if (exit_on_error)
792
                    loglevel = AV_LOG_ERROR;
793
                av_log(s, loglevel, "Non-monotonous DTS in output stream "
794
                       "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
795
                       ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
796
                if (exit_on_error) {
797
                    av_log(NULL, AV_LOG_FATAL, "aborting.\n");
798
                    exit_program(1);
799
                }
800
                av_log(s, loglevel, "changing to %"PRId64". This may result "
801
                       "in incorrect timestamps in the output file.\n",
802
                       max);
803
                if (pkt->pts >= pkt->dts)
804
                    pkt->pts = FFMAX(pkt->pts, max);
805
                pkt->dts = max;
806
            }
807
        }
808
    }
809
453105
    ost->last_mux_dts = pkt->dts;
810
811
453105
    ost->data_size += pkt->size;
812
453105
    ost->packets_written++;
813
814
453105
    pkt->stream_index = ost->index;
815
816
453105
    if (debug_ts) {
817
        av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
818
                "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
819
                av_get_media_type_string(ost->enc_ctx->codec_type),
820
                av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
821
                av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
822
                pkt->size
823
              );
824
    }
825
826
453105
    ret = av_interleaved_write_frame(s, pkt);
827
453105
    if (ret < 0) {
828
1
        print_error("av_interleaved_write_frame()", ret);
829
1
        main_return_code = 1;
830
1
        close_all_output_streams(ost, MUXER_FINISHED | ENCODER_FINISHED, ENCODER_FINISHED);
831
    }
832
453105
    av_packet_unref(pkt);
833
}
834
835
5705
static void close_output_stream(OutputStream *ost)
836
{
837
5705
    OutputFile *of = output_files[ost->file_index];
838
839
5705
    ost->finished |= ENCODER_FINISHED;
840
5705
    if (of->shortest) {
841
        int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);
842
        of->recording_time = FFMIN(of->recording_time, end);
843
    }
844
5705
}
845
846
/*
847
 * Send a single packet to the output, applying any bitstream filters
848
 * associated with the output stream.  This may result in any number
849
 * of packets actually being written, depending on what bitstream
850
 * filters are applied.  The supplied packet is consumed and will be
851
 * blank (as if newly-allocated) when this function returns.
852
 *
853
 * If eof is set, instead indicate EOF to all bitstream filters and
854
 * therefore flush any delayed packets to the output.  A blank packet
855
 * must be supplied in this case.
856
 */
857
458105
static void output_packet(OutputFile *of, AVPacket *pkt,
858
                          OutputStream *ost, int eof)
859
{
860
458105
    int ret = 0;
861
862
    /* apply the output bitstream filters, if any */
863
458105
    if (ost->nb_bitstream_filters) {
864
        int idx;
865
866
6641
        ret = av_bsf_send_packet(ost->bsf_ctx[0], eof ? NULL : pkt);
867
6641
        if (ret < 0)
868
            goto finish;
869
870
6641
        eof = 0;
871
6641
        idx = 1;
872
19915
        while (idx) {
873
            /* get a packet from the previous filter up the chain */
874
13278
            ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
875
13278
            if (ret == AVERROR(EAGAIN)) {
876
6637
                ret = 0;
877
6637
                idx--;
878
6637
                continue;
879
6641
            } else if (ret == AVERROR_EOF) {
880
3
                eof = 1;
881
6638
            } else if (ret < 0)
882
1
                goto finish;
883
884
            /* send it to the next filter down the chain or to the muxer */
885
6640
            if (idx < ost->nb_bitstream_filters) {
886
                ret = av_bsf_send_packet(ost->bsf_ctx[idx], eof ? NULL : pkt);
887
                if (ret < 0)
888
                    goto finish;
889
                idx++;
890
                eof = 0;
891
6640
            } else if (eof)
892
3
                goto finish;
893
            else
894
6637
                write_packet(of, pkt, ost, 0);
895
        }
896
451464
    } else if (!eof)
897
446781
        write_packet(of, pkt, ost, 0);
898
899
4683
finish:
900

458105
    if (ret < 0 && ret != AVERROR_EOF) {
901
1
        av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
902
               "packet for stream #%d:%d.\n", ost->file_index, ost->index);
903
1
        if(exit_on_error)
904
            exit_program(1);
905
    }
906
458105
}
907
908
428802
static int check_recording_time(OutputStream *ost)
909
{
910
428802
    OutputFile *of = output_files[ost->file_index];
911
912

436265
    if (of->recording_time != INT64_MAX &&
913
7463
        av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
914
7463
                      AV_TIME_BASE_Q) >= 0) {
915
1
        close_output_stream(ost);
916
1
        return 0;
917
    }
918
428801
    return 1;
919
}
920
921
329054
static void do_audio_out(OutputFile *of, OutputStream *ost,
922
                         AVFrame *frame)
923
{
924
329054
    AVCodecContext *enc = ost->enc_ctx;
925
    AVPacket pkt;
926
    int ret;
927
928
329054
    av_init_packet(&pkt);
929
329054
    pkt.data = NULL;
930
329054
    pkt.size = 0;
931
932
329054
    if (!check_recording_time(ost))
933
        return;
934
935

329054
    if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
936
        frame->pts = ost->sync_opts;
937
329054
    ost->sync_opts = frame->pts + frame->nb_samples;
938
329054
    ost->samples_encoded += frame->nb_samples;
939
329054
    ost->frames_encoded++;
940
941

329054
    av_assert0(pkt.size || !pkt.data);
942
329054
    update_benchmark(NULL);
943
329054
    if (debug_ts) {
944
        av_log(NULL, AV_LOG_INFO, "encoder <- type:audio "
945
               "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
946
               av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
947
               enc->time_base.num, enc->time_base.den);
948
    }
949
950
329054
    ret = avcodec_send_frame(enc, frame);
951
329054
    if (ret < 0)
952
        goto error;
953
954
    while (1) {
955
651952
        ret = avcodec_receive_packet(enc, &pkt);
956
651952
        if (ret == AVERROR(EAGAIN))
957
329054
            break;
958
322898
        if (ret < 0)
959
            goto error;
960
961
322898
        update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
962
963
322898
        av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
964
965
322898
        if (debug_ts) {
966
            av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
967
                   "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
968
                   av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
969
                   av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
970
        }
971
972
322898
        output_packet(of, &pkt, ost, 0);
973
    }
974
975
329054
    return;
976
error:
977
    av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
978
    exit_program(1);
979
}
980
981
595
static void do_subtitle_out(OutputFile *of,
982
                            OutputStream *ost,
983
                            AVSubtitle *sub)
984
{
985
595
    int subtitle_out_max_size = 1024 * 1024;
986
    int subtitle_out_size, nb, i;
987
    AVCodecContext *enc;
988
    AVPacket pkt;
989
    int64_t pts;
990
991
595
    if (sub->pts == AV_NOPTS_VALUE) {
992
        av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
993
        if (exit_on_error)
994
            exit_program(1);
995
        return;
996
    }
997
998
595
    enc = ost->enc_ctx;
999
1000
595
    if (!subtitle_out) {
1001
30
        subtitle_out = av_malloc(subtitle_out_max_size);
1002
30
        if (!subtitle_out) {
1003
            av_log(NULL, AV_LOG_FATAL, "Failed to allocate subtitle_out\n");
1004
            exit_program(1);
1005
        }
1006
    }
1007
1008
    /* Note: DVB subtitle need one packet to draw them and one other
1009
       packet to clear them */
1010
    /* XXX: signal it in the codec context ? */
1011
595
    if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
1012
        nb = 2;
1013
    else
1014
595
        nb = 1;
1015
1016
    /* shift timestamp to honor -ss and make check_recording_time() work with -t */
1017
595
    pts = sub->pts;
1018
595
    if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
1019
        pts -= output_files[ost->file_index]->start_time;
1020
1190
    for (i = 0; i < nb; i++) {
1021
595
        unsigned save_num_rects = sub->num_rects;
1022
1023
595
        ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
1024
595
        if (!check_recording_time(ost))
1025
            return;
1026
1027
595
        sub->pts = pts;
1028
        // start_display_time is required to be 0
1029
595
        sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1030
595
        sub->end_display_time  -= sub->start_display_time;
1031
595
        sub->start_display_time = 0;
1032
595
        if (i == 1)
1033
            sub->num_rects = 0;
1034
1035
595
        ost->frames_encoded++;
1036
1037
595
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1038
                                                    subtitle_out_max_size, sub);
1039
595
        if (i == 1)
1040
            sub->num_rects = save_num_rects;
1041
595
        if (subtitle_out_size < 0) {
1042
            av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1043
            exit_program(1);
1044
        }
1045
1046
595
        av_init_packet(&pkt);
1047
595
        pkt.data = subtitle_out;
1048
595
        pkt.size = subtitle_out_size;
1049
595
        pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->mux_timebase);
1050
595
        pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1051
595
        if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
1052
            /* XXX: the pts correction is handled here. Maybe handling
1053
               it in the codec would be better */
1054
            if (i == 0)
1055
                pkt.pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1056
            else
1057
                pkt.pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1058
        }
1059
595
        pkt.dts = pkt.pts;
1060
595
        output_packet(of, &pkt, ost, 0);
1061
    }
1062
}
1063
1064
101524
static void do_video_out(OutputFile *of,
1065
                         OutputStream *ost,
1066
                         AVFrame *next_picture,
1067
                         double sync_ipts)
1068
{
1069
    int ret, format_video_sync;
1070
    AVPacket pkt;
1071
101524
    AVCodecContext *enc = ost->enc_ctx;
1072
101524
    AVCodecParameters *mux_par = ost->st->codecpar;
1073
    AVRational frame_rate;
1074
    int nb_frames, nb0_frames, i;
1075
    double delta, delta0;
1076
101524
    double duration = 0;
1077
101524
    int frame_size = 0;
1078
101524
    InputStream *ist = NULL;
1079
101524
    AVFilterContext *filter = ost->filter->filter;
1080
1081
101524
    if (ost->source_index >= 0)
1082
100048
        ist = input_streams[ost->source_index];
1083
1084
101524
    frame_rate = av_buffersink_get_frame_rate(filter);
1085

101524
    if (frame_rate.num > 0 && frame_rate.den > 0)
1086
101395
        duration = 1/(av_q2d(frame_rate) * av_q2d(enc->time_base));
1087
1088


101524
    if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1089
65184
        duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
1090
1091
101524
    if (!ost->filters_script &&
1092
101427
        !ost->filters &&
1093

94923
        (nb_filtergraphs == 0 || !filtergraphs[0]->graph_desc) &&
1094
90529
        next_picture &&
1095
90529
        ist &&
1096
90529
        lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
1097
85802
        duration = lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
1098
    }
1099
1100
101524
    if (!next_picture) {
1101
        //end, flushing
1102
2410
        nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
1103
                                          ost->last_nb0_frames[1],
1104
                                          ost->last_nb0_frames[2]);
1105
    } else {
1106
99114
        delta0 = sync_ipts - ost->sync_opts; // delta0 is the "drift" between the input frame (next_picture) and where it would fall in the output.
1107
99114
        delta  = delta0 + duration;
1108
1109
        /* by default, we output a single frame */
1110
99114
        nb0_frames = 0; // tracks the number of times the PREVIOUS frame should be duplicated, mostly for variable framerate (VFR)
1111
99114
        nb_frames = 1;
1112
1113
99114
        format_video_sync = video_sync_method;
1114
99114
        if (format_video_sync == VSYNC_AUTO) {
1115
56087
            if(!strcmp(of->ctx->oformat->name, "avi")) {
1116
12650
                format_video_sync = VSYNC_VFR;
1117
            } else
1118

43437
                format_video_sync = (of->ctx->oformat->flags & AVFMT_VARIABLE_FPS) ? ((of->ctx->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
1119
56087
            if (   ist
1120
54654
                && format_video_sync == VSYNC_CFR
1121
9424
                && input_files[ist->file_index]->ctx->nb_streams == 1
1122
8349
                && input_files[ist->file_index]->input_ts_offset == 0) {
1123
8349
                format_video_sync = VSYNC_VSCFR;
1124
            }
1125

56087
            if (format_video_sync == VSYNC_CFR && copy_ts) {
1126
                format_video_sync = VSYNC_VSCFR;
1127
            }
1128
        }
1129

99114
        ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
1130
1131

99114
        if (delta0 < 0 &&
1132
11138
            delta > 0 &&
1133
10710
            format_video_sync != VSYNC_PASSTHROUGH &&
1134
            format_video_sync != VSYNC_DROP) {
1135
7941
            if (delta0 < -0.6) {
1136
431
                av_log(NULL, AV_LOG_VERBOSE, "Past duration %f too large\n", -delta0);
1137
            } else
1138
7510
                av_log(NULL, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
1139
7941
            sync_ipts = ost->sync_opts;
1140
7941
            duration += delta0;
1141
7941
            delta0 = 0;
1142
        }
1143
1144

99114
        switch (format_video_sync) {
1145
8349
        case VSYNC_VSCFR:
1146

8349
            if (ost->frame_number == 0 && delta0 >= 0.5) {
1147
                av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
1148
                delta = duration;
1149
                delta0 = 0;
1150
                ost->sync_opts = lrint(sync_ipts);
1151
            }
1152
        case VSYNC_CFR:
1153
            // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1154

9578
            if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
1155
                nb_frames = 0;
1156
9578
            } else if (delta < -1.1)
1157
                nb_frames = 0;
1158
9578
            else if (delta > 1.1) {
1159
350
                nb_frames = lrintf(delta);
1160
350
                if (delta0 > 1.1)
1161
2
                    nb0_frames = lrintf(delta0 - 0.6);
1162
            }
1163
9578
            break;
1164
46646
        case VSYNC_VFR:
1165
46646
            if (delta <= -0.6)
1166
170
                nb_frames = 0;
1167
46476
            else if (delta > 0.6)
1168
45894
                ost->sync_opts = lrint(sync_ipts);
1169
46646
            break;
1170
42890
        case VSYNC_DROP:
1171
        case VSYNC_PASSTHROUGH:
1172
42890
            ost->sync_opts = lrint(sync_ipts);
1173
42890
            break;
1174
        default:
1175
            av_assert0(0);
1176
        }
1177
    }
1178
1179
101524
    nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1180
101524
    nb0_frames = FFMIN(nb0_frames, nb_frames);
1181
1182
101524
    memmove(ost->last_nb0_frames + 1,
1183
101524
            ost->last_nb0_frames,
1184
            sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
1185
101524
    ost->last_nb0_frames[0] = nb0_frames;
1186
1187

101524
    if (nb0_frames == 0 && ost->last_dropped) {
1188
170
        nb_frames_drop++;
1189
170
        av_log(NULL, AV_LOG_VERBOSE,
1190
               "*** dropping frame %d from stream %d at ts %"PRId64"\n",
1191
170
               ost->frame_number, ost->st->index, ost->last_frame->pts);
1192
    }
1193

101524
    if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) {
1194
49
        if (nb_frames > dts_error_threshold * 30) {
1195
            av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
1196
            nb_frames_drop++;
1197
            return;
1198
        }
1199

49
        nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
1200
49
        av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1201
49
        if (nb_frames_dup > dup_warning) {
1202
            av_log(NULL, AV_LOG_WARNING, "More than %d frames duplicated\n", dup_warning);
1203
            dup_warning *= 10;
1204
        }
1205
    }
1206

101524
    ost->last_dropped = nb_frames == nb0_frames && next_picture;
1207
1208
    /* duplicates frame if needed */
1209
200676
    for (i = 0; i < nb_frames; i++) {
1210
        AVFrame *in_picture;
1211
99153
        int forced_keyframe = 0;
1212
        double pts_time;
1213
99153
        av_init_packet(&pkt);
1214
99153
        pkt.data = NULL;
1215
99153
        pkt.size = 0;
1216
1217

99153
        if (i < nb0_frames && ost->last_frame) {
1218
69
            in_picture = ost->last_frame;
1219
        } else
1220
99084
            in_picture = next_picture;
1221
1222
99153
        if (!in_picture)
1223
            return;
1224
1225
99153
        in_picture->pts = ost->sync_opts;
1226
1227
99153
        if (!check_recording_time(ost))
1228
1
            return;
1229
1230
99152
        if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
1231
1280
            ost->top_field_first >= 0)
1232
25
            in_picture->top_field_first = !!ost->top_field_first;
1233
1234
99152
        if (in_picture->interlaced_frame) {
1235
7261
            if (enc->codec->id == AV_CODEC_ID_MJPEG)
1236
                mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
1237
            else
1238
7261
                mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
1239
        } else
1240
91891
            mux_par->field_order = AV_FIELD_PROGRESSIVE;
1241
1242
99152
        in_picture->quality = enc->global_quality;
1243
99152
        in_picture->pict_type = 0;
1244
1245
99152
        if (ost->forced_kf_ref_pts == AV_NOPTS_VALUE &&
1246
4592
            in_picture->pts != AV_NOPTS_VALUE)
1247
4592
            ost->forced_kf_ref_pts = in_picture->pts;
1248
1249
198304
        pts_time = in_picture->pts != AV_NOPTS_VALUE ?
1250
99152
            (in_picture->pts - ost->forced_kf_ref_pts) * av_q2d(enc->time_base) : NAN;
1251
99152
        if (ost->forced_kf_index < ost->forced_kf_count &&
1252
39
            in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1253
2
            ost->forced_kf_index++;
1254
2
            forced_keyframe = 1;
1255
99150
        } else if (ost->forced_keyframes_pexpr) {
1256
            double res;
1257
            ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
1258
            res = av_expr_eval(ost->forced_keyframes_pexpr,
1259
                               ost->forced_keyframes_expr_const_values, NULL);
1260
            ff_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
1261
                    ost->forced_keyframes_expr_const_values[FKF_N],
1262
                    ost->forced_keyframes_expr_const_values[FKF_N_FORCED],
1263
                    ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],
1264
                    ost->forced_keyframes_expr_const_values[FKF_T],
1265
                    ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],
1266
                    res);
1267
            if (res) {
1268
                forced_keyframe = 1;
1269
                ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =
1270
                    ost->forced_keyframes_expr_const_values[FKF_N];
1271
                ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =
1272
                    ost->forced_keyframes_expr_const_values[FKF_T];
1273
                ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;
1274
            }
1275
1276
            ost->forced_keyframes_expr_const_values[FKF_N] += 1;
1277
99150
        } else if (   ost->forced_keyframes
1278
48
                   && !strncmp(ost->forced_keyframes, "source", 6)
1279
                   && in_picture->key_frame==1
1280
                   && !i) {
1281
            forced_keyframe = 1;
1282
        }
1283
1284
99152
        if (forced_keyframe) {
1285
2
            in_picture->pict_type = AV_PICTURE_TYPE_I;
1286
2
            av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
1287
        }
1288
1289
99152
        update_benchmark(NULL);
1290
99152
        if (debug_ts) {
1291
            av_log(NULL, AV_LOG_INFO, "encoder <- type:video "
1292
                   "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1293
                   av_ts2str(in_picture->pts), av_ts2timestr(in_picture->pts, &enc->time_base),
1294
                   enc->time_base.num, enc->time_base.den);
1295
        }
1296
1297
99152
        ost->frames_encoded++;
1298
1299
99152
        ret = avcodec_send_frame(enc, in_picture);
1300
99152
        if (ret < 0)
1301
            goto error;
1302
        // Make sure Closed Captions will not be duplicated
1303
99152
        av_frame_remove_side_data(in_picture, AV_FRAME_DATA_A53_CC);
1304
1305
        while (1) {
1306
198101
            ret = avcodec_receive_packet(enc, &pkt);
1307
198101
            update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1308
198101
            if (ret == AVERROR(EAGAIN))
1309
99152
                break;
1310
98949
            if (ret < 0)
1311
                goto error;
1312
1313
98949
            if (debug_ts) {
1314
                av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1315
                       "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1316
                       av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
1317
                       av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
1318
            }
1319
1320

98949
            if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
1321
                pkt.pts = ost->sync_opts;
1322
1323
98949
            av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1324
1325
98949
            if (debug_ts) {
1326
                av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1327
                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1328
                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->mux_timebase),
1329
                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->mux_timebase));
1330
            }
1331
1332
98949
            frame_size = pkt.size;
1333
98949
            output_packet(of, &pkt, ost, 0);
1334
1335
            /* if two pass, output log */
1336

98949
            if (ost->logfile && enc->stats_out) {
1337
                fprintf(ost->logfile, "%s", enc->stats_out);
1338
            }
1339
        }
1340
99152
        ost->sync_opts++;
1341
        /*
1342
         * For video, number of frames in == number of packets out.
1343
         * But there may be reordering, so we can't throw away frames on encoder
1344
         * flush, we need to limit them here, before they go into encoder.
1345
         */
1346
99152
        ost->frame_number++;
1347
1348

99152
        if (vstats_filename && frame_size)
1349
            do_video_stats(ost, frame_size);
1350
    }
1351
1352
101523
    if (!ost->last_frame)
1353
4676
        ost->last_frame = av_frame_alloc();
1354
101523
    av_frame_unref(ost->last_frame);
1355

101523
    if (next_picture && ost->last_frame)
1356
99113
        av_frame_ref(ost->last_frame, next_picture);
1357
    else
1358
2410
        av_frame_free(&ost->last_frame);
1359
1360
101523
    return;
1361
error:
1362
    av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1363
    exit_program(1);
1364
}
1365
1366
static double psnr(double d)
1367
{
1368
    return -10.0 * log10(d);
1369
}
1370
1371
static void do_video_stats(OutputStream *ost, int frame_size)
1372
{
1373
    AVCodecContext *enc;
1374
    int frame_number;
1375
    double ti1, bitrate, avg_bitrate;
1376
1377
    /* this is executed just the first time do_video_stats is called */
1378
    if (!vstats_file) {
1379
        vstats_file = fopen(vstats_filename, "w");
1380
        if (!vstats_file) {
1381
            perror("fopen");
1382
            exit_program(1);
1383
        }
1384
    }
1385
1386
    enc = ost->enc_ctx;
1387
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1388
        frame_number = ost->st->nb_frames;
1389
        if (vstats_version <= 1) {
1390
            fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
1391
                    ost->quality / (float)FF_QP2LAMBDA);
1392
        } else  {
1393
            fprintf(vstats_file, "out= %2d st= %2d frame= %5d q= %2.1f ", ost->file_index, ost->index, frame_number,
1394
                    ost->quality / (float)FF_QP2LAMBDA);
1395
        }
1396
1397
        if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
1398
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1399
1400
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1401
        /* compute pts value */
1402
        ti1 = av_stream_get_end_pts(ost->st) * av_q2d(ost->st->time_base);
1403
        if (ti1 < 0.01)
1404
            ti1 = 0.01;
1405
1406
        bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1407
        avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
1408
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1409
               (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
1410
        fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(ost->pict_type));
1411
    }
1412
}
1413
1414
static int init_output_stream(OutputStream *ost, char *error, int error_len);
1415
1416
306
static void finish_output_stream(OutputStream *ost)
1417
{
1418
306
    OutputFile *of = output_files[ost->file_index];
1419
    int i;
1420
1421
306
    ost->finished = ENCODER_FINISHED | MUXER_FINISHED;
1422
1423
306
    if (of->shortest) {
1424
        for (i = 0; i < of->ctx->nb_streams; i++)
1425
            output_streams[of->ost_index + i]->finished = ENCODER_FINISHED | MUXER_FINISHED;
1426
    }
1427
306
}
1428
1429
/**
1430
 * Get and encode new output from any of the filtergraphs, without causing
1431
 * activity.
1432
 *
1433
 * @return  0 for success, <0 for severe errors
1434
 */
1435
444325
static int reap_filters(int flush)
1436
{
1437
444325
    AVFrame *filtered_frame = NULL;
1438
    int i;
1439
1440
    /* Reap all buffers present in the buffer sinks */
1441
903293
    for (i = 0; i < nb_output_streams; i++) {
1442
458968
        OutputStream *ost = output_streams[i];
1443
458968
        OutputFile    *of = output_files[ost->file_index];
1444
        AVFilterContext *filter;
1445
458968
        AVCodecContext *enc = ost->enc_ctx;
1446
458968
        int ret = 0;
1447
1448

458968
        if (!ost->filter || !ost->filter->graph->graph)
1449
47298
            continue;
1450
411670
        filter = ost->filter->filter;
1451
1452
411670
        if (!ost->initialized) {
1453
5654
            char error[1024] = "";
1454
5654
            ret = init_output_stream(ost, error, sizeof(error));
1455
5654
            if (ret < 0) {
1456
                av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1457
                       ost->file_index, ost->index, error);
1458
                exit_program(1);
1459
            }
1460
        }
1461
1462

411670
        if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
1463
            return AVERROR(ENOMEM);
1464
        }
1465
411670
        filtered_frame = ost->filtered_frame;
1466
1467
428168
        while (1) {
1468
839838
            double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
1469
839838
            ret = av_buffersink_get_frame_flags(filter, filtered_frame,
1470
                                               AV_BUFFERSINK_FLAG_NO_REQUEST);
1471
839838
            if (ret < 0) {
1472

411670
                if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1473
                    av_log(NULL, AV_LOG_WARNING,
1474
                           "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1475

411670
                } else if (flush && ret == AVERROR_EOF) {
1476
3544
                    if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
1477
2410
                        do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
1478
                }
1479
411670
                break;
1480
            }
1481
428168
            if (ost->finished) {
1482
                av_frame_unref(filtered_frame);
1483
                continue;
1484
            }
1485
428168
            if (filtered_frame->pts != AV_NOPTS_VALUE) {
1486
428168
                int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1487
428168
                AVRational filter_tb = av_buffersink_get_time_base(filter);
1488
428168
                AVRational tb = enc->time_base;
1489
428168
                int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
1490
1491
428168
                tb.den <<= extra_bits;
1492
428168
                float_pts =
1493
428168
                    av_rescale_q(filtered_frame->pts, filter_tb, tb) -
1494
428168
                    av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
1495
428168
                float_pts /= 1 << extra_bits;
1496
                // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
1497
428168
                float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
1498
1499
428168
                filtered_frame->pts =
1500
428168
                    av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
1501
428168
                    av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
1502
            }
1503
1504
428168
            switch (av_buffersink_get_type(filter)) {
1505
99114
            case AVMEDIA_TYPE_VIDEO:
1506
99114
                if (!ost->frame_aspect_ratio.num)
1507
99114
                    enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
1508
1509
99114
                if (debug_ts) {
1510
                    av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
1511
                            av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
1512
                            float_pts,
1513
                            enc->time_base.num, enc->time_base.den);
1514
                }
1515
1516
99114
                do_video_out(of, ost, filtered_frame, float_pts);
1517
99114
                break;
1518
329054
            case AVMEDIA_TYPE_AUDIO:
1519
329054
                if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
1520
329054
                    enc->channels != filtered_frame->channels) {
1521
                    av_log(NULL, AV_LOG_ERROR,
1522
                           "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1523
                    break;
1524
                }
1525
329054
                do_audio_out(of, ost, filtered_frame);
1526
329054
                break;
1527
            default:
1528
                // TODO support subtitle filters
1529
                av_assert0(0);
1530
            }
1531
1532
428168
            av_frame_unref(filtered_frame);
1533
        }
1534
    }
1535
1536
444325
    return 0;
1537
}
1538
1539
5870
static void print_final_stats(int64_t total_size)
1540
{
1541
5870
    uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
1542
5870
    uint64_t subtitle_size = 0;
1543
5870
    uint64_t data_size = 0;
1544
5870
    float percent = -1.0;
1545
    int i, j;
1546
5870
    int pass1_used = 1;
1547
1548
11884
    for (i = 0; i < nb_output_streams; i++) {
1549
6014
        OutputStream *ost = output_streams[i];
1550

6014
        switch (ost->enc_ctx->codec_type) {
1551
4764
            case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1552
1202
            case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1553
37
            case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1554
11
            default:                 other_size += ost->data_size; break;
1555
        }
1556
6014
        extra_size += ost->enc_ctx->extradata_size;
1557
6014
        data_size  += ost->data_size;
1558
6014
        if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2))
1559
            != AV_CODEC_FLAG_PASS1)
1560
6014
            pass1_used = 0;
1561
    }
1562
1563

5870
    if (data_size && total_size>0 && total_size >= data_size)
1564
4061
        percent = 100.0 * (total_size - data_size) / data_size;
1565
1566
5870
    av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
1567
           video_size / 1024.0,
1568
           audio_size / 1024.0,
1569
           subtitle_size / 1024.0,
1570
           other_size / 1024.0,
1571
           extra_size / 1024.0);
1572
5870
    if (percent >= 0.0)
1573
4061
        av_log(NULL, AV_LOG_INFO, "%f%%", percent);
1574
    else
1575
1809
        av_log(NULL, AV_LOG_INFO, "unknown");
1576
5870
    av_log(NULL, AV_LOG_INFO, "\n");
1577
1578
    /* print verbose per-stream stats */
1579
11772
    for (i = 0; i < nb_input_files; i++) {
1580
5902
        InputFile *f = input_files[i];
1581
5902
        uint64_t total_packets = 0, total_size = 0;
1582
1583
5902
        av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
1584
5902
               i, f->ctx->url);
1585
1586
12122
        for (j = 0; j < f->nb_streams; j++) {
1587
6220
            InputStream *ist = input_streams[f->ist_index + j];
1588
6220
            enum AVMediaType type = ist->dec_ctx->codec_type;
1589
1590
6220
            total_size    += ist->data_size;
1591
6220
            total_packets += ist->nb_packets;
1592
1593
6220
            av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
1594
                   i, j, media_type_string(type));
1595
6220
            av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
1596
                   ist->nb_packets, ist->data_size);
1597
1598
6220
            if (ist->decoding_needed) {
1599
5702
                av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
1600
                       ist->frames_decoded);
1601
5702
                if (type == AVMEDIA_TYPE_AUDIO)
1602
1102
                    av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
1603
5702
                av_log(NULL, AV_LOG_VERBOSE, "; ");
1604
            }
1605
1606
6220
            av_log(NULL, AV_LOG_VERBOSE, "\n");
1607
        }
1608
1609
5902
        av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
1610
               total_packets, total_size);
1611
    }
1612
1613
11741
    for (i = 0; i < nb_output_files; i++) {
1614
5871
        OutputFile *of = output_files[i];
1615
5871
        uint64_t total_packets = 0, total_size = 0;
1616
1617
5871
        av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
1618
5871
               i, of->ctx->url);
1619
1620
11885
        for (j = 0; j < of->ctx->nb_streams; j++) {
1621
6014
            OutputStream *ost = output_streams[of->ost_index + j];
1622
6014
            enum AVMediaType type = ost->enc_ctx->codec_type;
1623
1624
6014
            total_size    += ost->data_size;
1625
6014
            total_packets += ost->packets_written;
1626
1627
6014
            av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
1628
                   i, j, media_type_string(type));
1629
6014
            if (ost->encoding_needed) {
1630
5723
                av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
1631
                       ost->frames_encoded);
1632
5723
                if (type == AVMEDIA_TYPE_AUDIO)
1633
1100
                    av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
1634
5723
                av_log(NULL, AV_LOG_VERBOSE, "; ");
1635
            }
1636
1637
6014
            av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
1638
                   ost->packets_written, ost->data_size);
1639
1640
6014
            av_log(NULL, AV_LOG_VERBOSE, "\n");
1641
        }
1642
1643
5871
        av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
1644
               total_packets, total_size);
1645
    }
1646
5870
    if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
1647
5
        av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
1648
5
        if (pass1_used) {
1649
1
            av_log(NULL, AV_LOG_WARNING, "\n");
1650
        } else {
1651
4
            av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
1652
        }
1653
    }
1654
5870
}
1655
1656
1244974
static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1657
{
1658
    AVBPrint buf, buf_script;
1659
    OutputStream *ost;
1660
    AVFormatContext *oc;
1661
    int64_t total_size;
1662
    AVCodecContext *enc;
1663
    int frame_number, vid, i;
1664
    double bitrate;
1665
    double speed;
1666
1244974
    int64_t pts = INT64_MIN + 1;
1667
    static int64_t last_time = -1;
1668
    static int qp_histogram[52];
1669
    int hours, mins, secs, us;
1670
    const char *hours_sign;
1671
    int ret;
1672
    float t;
1673
1674

1244974
    if (!print_stats && !is_last_report && !progress_avio)
1675
1239079
        return;
1676
1677
15950
    if (!is_last_report) {
1678
10080
        if (last_time == -1) {
1679
31
            last_time = cur_time;
1680
31
            return;
1681
        }
1682
10049
        if ((cur_time - last_time) < 500000)
1683
10024
            return;
1684
25
        last_time = cur_time;
1685
    }
1686
1687
5895
    t = (cur_time-timer_start) / 1000000.0;
1688
1689
1690
5895
    oc = output_files[0]->ctx;
1691
1692
5895
    total_size = avio_size(oc->pb);
1693
5895
    if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1694
76
        total_size = avio_tell(oc->pb);
1695
1696
5895
    vid = 0;
1697
5895
    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1698
5895
    av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
1699
11934
    for (i = 0; i < nb_output_streams; i++) {
1700
6039
        float q = -1;
1701
6039
        ost = output_streams[i];
1702
6039
        enc = ost->enc_ctx;
1703
6039
        if (!ost->stream_copy)
1704
5749
            q = ost->quality / (float) FF_QP2LAMBDA;
1705
1706

6039
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1707
8
            av_bprintf(&buf, "q=%2.1f ", q);
1708
8
            av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1709
                       ost->file_index, ost->index, q);
1710
        }
1711

6039
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1712
            float fps;
1713
1714
4758
            frame_number = ost->frame_number;
1715
4758
            fps = t > 1 ? frame_number / t : 0;
1716
4758
            av_bprintf(&buf, "frame=%5d fps=%3.*f q=%3.1f ",
1717
                     frame_number, fps < 9.95, fps, q);
1718
4758
            av_bprintf(&buf_script, "frame=%d\n", frame_number);
1719
4758
            av_bprintf(&buf_script, "fps=%.2f\n", fps);
1720
4758
            av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1721
                       ost->file_index, ost->index, q);
1722
4758
            if (is_last_report)
1723
4756
                av_bprintf(&buf, "L");
1724
4758
            if (qp_hist) {
1725
                int j;
1726
                int qp = lrintf(q);
1727
                if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1728
                    qp_histogram[qp]++;
1729
                for (j = 0; j < 32; j++)
1730
                    av_bprintf(&buf, "%X", av_log2(qp_histogram[j] + 1));
1731
            }
1732
1733

4758
            if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
1734
                int j;
1735
                double error, error_sum = 0;
1736
                double scale, scale_sum = 0;
1737
                double p;
1738
                char type[3] = { 'Y','U','V' };
1739
                av_bprintf(&buf, "PSNR=");
1740
                for (j = 0; j < 3; j++) {
1741
                    if (is_last_report) {
1742
                        error = enc->error[j];
1743
                        scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1744
                    } else {
1745
                        error = ost->error[j];
1746
                        scale = enc->width * enc->height * 255.0 * 255.0;
1747
                    }
1748
                    if (j)
1749
                        scale /= 4;
1750
                    error_sum += error;
1751
                    scale_sum += scale;
1752
                    p = psnr(error / scale);
1753
                    av_bprintf(&buf, "%c:%2.2f ", type[j], p);
1754
                    av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
1755
                               ost->file_index, ost->index, type[j] | 32, p);
1756
                }
1757
                p = psnr(error_sum / scale_sum);
1758
                av_bprintf(&buf, "*:%2.2f ", psnr(error_sum / scale_sum));
1759
                av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1760
                           ost->file_index, ost->index, p);
1761
            }
1762
4758
            vid = 1;
1763
        }
1764
        /* compute min output value */
1765
6039
        if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE)
1766
6039
            pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
1767
                                          ost->st->time_base, AV_TIME_BASE_Q));
1768
6039
        if (is_last_report)
1769
6014
            nb_frames_drop += ost->last_dropped;
1770
    }
1771
1772
5895
    secs = FFABS(pts) / AV_TIME_BASE;
1773
5895
    us = FFABS(pts) % AV_TIME_BASE;
1774
5895
    mins = secs / 60;
1775
5895
    secs %= 60;
1776
5895
    hours = mins / 60;
1777
5895
    mins %= 60;
1778
5895
    hours_sign = (pts < 0) ? "-" : "";
1779
1780

5895
    bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1781
5895
    speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
1782
1783
5895
    if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
1784
5819
    else                av_bprintf(&buf, "size=%8.0fkB time=", total_size / 1024.0);
1785
5895
    if (pts == AV_NOPTS_VALUE) {
1786
        av_bprintf(&buf, "N/A ");
1787
    } else {
1788
5895
        av_bprintf(&buf, "%s%02d:%02d:%02d.%02d ",
1789
                   hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
1790
    }
1791
1792
5895
    if (bitrate < 0) {
1793
87
        av_bprintf(&buf, "bitrate=N/A");
1794
87
        av_bprintf(&buf_script, "bitrate=N/A\n");
1795
    }else{
1796
5808
        av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
1797
5808
        av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1798
    }
1799
1800
5895
    if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1801
5819
    else                av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1802
5895
    if (pts == AV_NOPTS_VALUE) {
1803
        av_bprintf(&buf_script, "out_time_us=N/A\n");
1804
        av_bprintf(&buf_script, "out_time_ms=N/A\n");
1805
        av_bprintf(&buf_script, "out_time=N/A\n");
1806
    } else {
1807
5895
        av_bprintf(&buf_script, "out_time_us=%"PRId64"\n", pts);
1808
5895
        av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1809
5895
        av_bprintf(&buf_script, "out_time=%s%02d:%02d:%02d.%06d\n",
1810
                   hours_sign, hours, mins, secs, us);
1811
    }
1812
1813

5895
    if (nb_frames_dup || nb_frames_drop)
1814
26
        av_bprintf(&buf, " dup=%d drop=%d", nb_frames_dup, nb_frames_drop);
1815
5895
    av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1816
5895
    av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1817
1818
5895
    if (speed < 0) {
1819
1
        av_bprintf(&buf, " speed=N/A");
1820
1
        av_bprintf(&buf_script, "speed=N/A\n");
1821
    } else {
1822
5894
        av_bprintf(&buf, " speed=%4.3gx", speed);
1823
5894
        av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
1824
    }
1825
1826

5895
    if (print_stats || is_last_report) {
1827
5895
        const char end = is_last_report ? '\n' : '\r';
1828

5895
        if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
1829
            fprintf(stderr, "%s    %c", buf.str, end);
1830
        } else
1831
5895
            av_log(NULL, AV_LOG_INFO, "%s    %c", buf.str, end);
1832
1833
5895
        fflush(stderr);
1834
    }
1835
5895
    av_bprint_finalize(&buf, NULL);
1836
1837
5895
    if (progress_avio) {
1838
        av_bprintf(&buf_script, "progress=%s\n",
1839
                   is_last_report ? "end" : "continue");
1840
        avio_write(progress_avio, buf_script.str,
1841
                   FFMIN(buf_script.len, buf_script.size - 1));
1842
        avio_flush(progress_avio);
1843
        av_bprint_finalize(&buf_script, NULL);
1844
        if (is_last_report) {
1845
            if ((ret = avio_closep(&progress_avio)) < 0)
1846
                av_log(NULL, AV_LOG_ERROR,
1847
                       "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
1848
        }
1849
    }
1850
1851
5895
    if (is_last_report)
1852
5870
        print_final_stats(total_size);
1853
}
1854
1855
static void ifilter_parameters_from_codecpar(InputFilter *ifilter, AVCodecParameters *par)
1856
{
1857
    // We never got any input. Set a fake format, which will
1858
    // come from libavformat.
1859
    ifilter->format                 = par->format;
1860
    ifilter->sample_rate            = par->sample_rate;
1861
    ifilter->channels               = par->channels;
1862
    ifilter->channel_layout         = par->channel_layout;
1863
    ifilter->width                  = par->width;
1864
    ifilter->height                 = par->height;
1865
    ifilter->sample_aspect_ratio    = par->sample_aspect_ratio;
1866
}
1867
1868
5870
static void flush_encoders(void)
1869
{
1870
    int i, ret;
1871
1872
11884
    for (i = 0; i < nb_output_streams; i++) {
1873
6014
        OutputStream   *ost = output_streams[i];
1874
6014
        AVCodecContext *enc = ost->enc_ctx;
1875
6014
        OutputFile      *of = output_files[ost->file_index];
1876
1877
6014
        if (!ost->encoding_needed)
1878
291
            continue;
1879
1880
        // Try to enable encoding with no input frames.
1881
        // Maybe we should just let encoding fail instead.
1882
5723
        if (!ost->initialized) {
1883
            FilterGraph *fg = ost->filter->graph;
1884
            char error[1024] = "";
1885
1886
            av_log(NULL, AV_LOG_WARNING,
1887
                   "Finishing stream %d:%d without any data written to it.\n",
1888
                   ost->file_index, ost->st->index);
1889
1890
            if (ost->filter && !fg->graph) {
1891
                int x;
1892
                for (x = 0; x < fg->nb_inputs; x++) {
1893
                    InputFilter *ifilter = fg->inputs[x];
1894
                    if (ifilter->format < 0)
1895
                        ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
1896
                }
1897
1898
                if (!ifilter_has_all_input_formats(fg))
1899
                    continue;
1900
1901
                ret = configure_filtergraph(fg);
1902
                if (ret < 0) {
1903
                    av_log(NULL, AV_LOG_ERROR, "Error configuring filter graph\n");
1904
                    exit_program(1);
1905
                }
1906
1907
                finish_output_stream(ost);
1908
            }
1909
1910
            ret = init_output_stream(ost, error, sizeof(error));
1911
            if (ret < 0) {
1912
                av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1913
                       ost->file_index, ost->index, error);
1914
                exit_program(1);
1915
            }
1916
        }
1917
1918

5723
        if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1919
1007
            continue;
1920
1921

4716
        if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
1922
30
            continue;
1923
1924
242
        for (;;) {
1925
4928
            const char *desc = NULL;
1926
            AVPacket pkt;
1927
            int pkt_size;
1928
1929
4928
            switch (enc->codec_type) {
1930
132
            case AVMEDIA_TYPE_AUDIO:
1931
132
                desc   = "audio";
1932
132
                break;
1933
4796
            case AVMEDIA_TYPE_VIDEO:
1934
4796
                desc   = "video";
1935
4796
                break;
1936
            default:
1937
                av_assert0(0);
1938
            }
1939
1940
4928
            av_init_packet(&pkt);
1941
4928
            pkt.data = NULL;
1942
4928
            pkt.size = 0;
1943
1944
4928
            update_benchmark(NULL);
1945
1946
9614
            while ((ret = avcodec_receive_packet(enc, &pkt)) == AVERROR(EAGAIN)) {
1947
4686
                ret = avcodec_send_frame(enc, NULL);
1948
4686
                if (ret < 0) {
1949
                    av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1950
                           desc,
1951
                           av_err2str(ret));
1952
                    exit_program(1);
1953
                }
1954
            }
1955
1956
4928
            update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
1957

4928
            if (ret < 0 && ret != AVERROR_EOF) {
1958
                av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1959
                       desc,
1960
                       av_err2str(ret));
1961
                exit_program(1);
1962
            }
1963

4928
            if (ost->logfile && enc->stats_out) {
1964
                fprintf(ost->logfile, "%s", enc->stats_out);
1965
            }
1966
4928
            if (ret == AVERROR_EOF) {
1967
4686
                output_packet(of, &pkt, ost, 1);
1968
4686
                break;
1969
            }
1970
242
            if (ost->finished & MUXER_FINISHED) {
1971
                av_packet_unref(&pkt);
1972
                continue;
1973
            }
1974
242
            av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1975
242
            pkt_size = pkt.size;
1976
242
            output_packet(of, &pkt, ost, 0);
1977

242
            if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1978
                do_video_stats(ost, pkt_size);
1979
            }
1980
        }
1981
    }
1982
5870
}
1983
1984
/*
1985
 * Check whether a packet from ist should be written into ost at this time
1986
 */
1987
446589
static int check_output_constraints(InputStream *ist, OutputStream *ost)
1988
{
1989
446589
    OutputFile *of = output_files[ost->file_index];
1990
446589
    int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1991
1992
446589
    if (ost->source_index != ist_index)
1993
16995
        return 0;
1994
1995
429594
    if (ost->finished)
1996
2814
        return 0;
1997
1998

426780
    if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1999
        return 0;
2000
2001
426780
    return 1;
2002
}
2003
2004
30754
static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2005
{
2006
30754
    OutputFile *of = output_files[ost->file_index];
2007
30754
    InputFile   *f = input_files [ist->file_index];
2008
30754
    int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
2009
30754
    int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
2010
    AVPacket opkt;
2011
2012
    // EOF: flush output bitstream filters.
2013
30754
    if (!pkt) {
2014
        av_init_packet(&opkt);
2015
        opkt.data = NULL;
2016
        opkt.size = 0;
2017
        output_packet(of, &opkt, ost, 1);
2018
19
        return;
2019
    }
2020
2021

30754
    if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2022
12
        !ost->copy_initial_nonkeyframes)
2023
12
        return;
2024
2025

30742
    if (!ost->frame_number && !ost->copy_prior_start) {
2026
        int64_t comp_start = start_time;
2027
        if (copy_ts && f->start_time != AV_NOPTS_VALUE)
2028
            comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
2029
        if (pkt->pts == AV_NOPTS_VALUE ?
2030
            ist->pts < comp_start :
2031
            pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
2032
            return;
2033
    }
2034
2035
30742
    if (of->recording_time != INT64_MAX &&
2036
416
        ist->pts >= of->recording_time + start_time) {
2037
5
        close_output_stream(ost);
2038
5
        return;
2039
    }
2040
2041
30737
    if (f->recording_time != INT64_MAX) {
2042
148
        start_time = f->ctx->start_time;
2043

148
        if (f->start_time != AV_NOPTS_VALUE && copy_ts)
2044
74
            start_time += f->start_time;
2045
148
        if (ist->pts >= f->recording_time + start_time) {
2046
2
            close_output_stream(ost);
2047
2
            return;
2048
        }
2049
    }
2050
2051
    /* force the input stream PTS */
2052
30735
    if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2053
9931
        ost->sync_opts++;
2054
2055
30735
    if (av_packet_ref(&opkt, pkt) < 0)
2056
        exit_program(1);
2057
2058
30735
    if (pkt->pts != AV_NOPTS_VALUE)
2059
25283
        opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
2060
2061
30735
    if (pkt->dts == AV_NOPTS_VALUE) {
2062
5200
        opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->mux_timebase);
2063
25535
    } else if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2064
20273
        int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
2065
20273
        if(!duration)
2066
7518
            duration = ist->dec_ctx->frame_size;
2067
40546
        opkt.dts = av_rescale_delta(ist->st->time_base, pkt->dts,
2068
20273
                                    (AVRational){1, ist->dec_ctx->sample_rate}, duration,
2069
                                    &ist->filter_in_rescale_delta_last, ost->mux_timebase);
2070
        /* dts will be set immediately afterwards to what pts is now */
2071
20273
        opkt.pts = opkt.dts - ost_tb_start_time;
2072
    } else
2073
5262
        opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
2074
30735
    opkt.dts -= ost_tb_start_time;
2075
2076
30735
    opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
2077
2078
30735
    output_packet(of, &opkt, ost, 0);
2079
}
2080
2081
1342
int guess_input_channel_layout(InputStream *ist)
2082
{
2083
1342
    AVCodecContext *dec = ist->dec_ctx;
2084
2085
1342
    if (!dec->channel_layout) {
2086
        char layout_name[256];
2087
2088
742
        if (dec->channels > ist->guess_layout_max)
2089
6
            return 0;
2090
738
        dec->channel_layout = av_get_default_channel_layout(dec->channels);
2091
738
        if (!dec->channel_layout)
2092
2
            return 0;
2093
736
        av_get_channel_layout_string(layout_name, sizeof(layout_name),
2094
                                     dec->channels, dec->channel_layout);
2095
736
        av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2096
736
               "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2097
    }
2098
1336
    return 1;
2099
}
2100
2101
807907
static void check_decode_result(InputStream *ist, int *got_output, int ret)
2102
{
2103

807907
    if (*got_output || ret<0)
2104
415748
        decode_error_stat[ret<0] ++;
2105
2106

807907
    if (ret < 0 && exit_on_error)
2107
        exit_program(1);
2108
2109

807907
    if (*got_output && ist) {
2110

414645
        if (ist->decoded_frame->decode_error_flags || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
2111
36
            av_log(NULL, exit_on_error ? AV_LOG_FATAL : AV_LOG_WARNING,
2112
36
                   "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->url, ist->st->index);
2113
36
            if (exit_on_error)
2114
                exit_program(1);
2115
        }
2116
    }
2117
807907
}
2118
2119
// Filters can be configured only if the formats of all inputs are known.
2120
810809
static int ifilter_has_all_input_formats(FilterGraph *fg)
2121
{
2122
    int i;
2123
859424
    for (i = 0; i < fg->nb_inputs; i++) {
2124

853676
        if (fg->inputs[i]->format < 0 && (fg->inputs[i]->type == AVMEDIA_TYPE_AUDIO ||
2125
805042
                                          fg->inputs[i]->type == AVMEDIA_TYPE_VIDEO))
2126
805061
            return 0;
2127
    }
2128
5748
    return 1;
2129
}
2130
2131
415033
static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
2132
{
2133
415033
    FilterGraph *fg = ifilter->graph;
2134
    int need_reinit, ret, i;
2135
2136
    /* determine if the parameters for this input changed */
2137
415033
    need_reinit = ifilter->format != frame->format;
2138
2139
415033
    switch (ifilter->ist->st->codecpar->codec_type) {
2140
316170
    case AVMEDIA_TYPE_AUDIO:
2141
947407
        need_reinit |= ifilter->sample_rate    != frame->sample_rate ||
2142

631236
                       ifilter->channels       != frame->channels ||
2143
315066
                       ifilter->channel_layout != frame->channel_layout;
2144
316170
        break;
2145
98863
    case AVMEDIA_TYPE_VIDEO:
2146
193136
        need_reinit |= ifilter->width  != frame->width ||
2147
94273
                       ifilter->height != frame->height;
2148
98863
        break;
2149
    }
2150
2151

415033
    if (!ifilter->ist->reinit_filters && fg->graph)
2152
        need_reinit = 0;
2153
2154
415033
    if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
2155

415033
        (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
2156
        need_reinit = 1;
2157
2158
415033
    if (need_reinit) {
2159
5707
        ret = ifilter_parameters_from_frame(ifilter, frame);
2160
5707
        if (ret < 0)
2161
            return ret;
2162
    }
2163
2164
    /* (re)init the graph if possible, otherwise buffer the frame and return */
2165

415033
    if (need_reinit || !fg->graph) {
2166
11416
        for (i = 0; i < fg->nb_inputs; i++) {
2167
5728
            if (!ifilter_has_all_input_formats(fg)) {
2168
19
                AVFrame *tmp = av_frame_clone(frame);
2169
19
                if (!tmp)
2170
                    return AVERROR(ENOMEM);
2171
19
                av_frame_unref(frame);
2172
2173
19
                if (!av_fifo_space(ifilter->frame_queue)) {
2174
                    ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
2175
                    if (ret < 0) {
2176
                        av_frame_free(&tmp);
2177
                        return ret;
2178
                    }
2179
                }
2180
19
                av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
2181
19
                return 0;
2182
            }
2183
        }
2184
2185
5688
        ret = reap_filters(1);
2186

5688
        if (ret < 0 && ret != AVERROR_EOF) {
2187
            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2188
            return ret;
2189
        }
2190
2191
5688
        ret = configure_filtergraph(fg);
2192
5688
        if (ret < 0) {
2193
            av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
2194
            return ret;
2195
        }
2196
    }
2197
2198
415014
    ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, AV_BUFFERSRC_FLAG_PUSH);
2199
415014
    if (ret < 0) {
2200
        if (ret != AVERROR_EOF)
2201
            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2202
        return ret;
2203
    }
2204
2205
415014
    return 0;
2206
}
2207
2208
5662
static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
2209
{
2210
    int ret;
2211
2212
5662
    ifilter->eof = 1;
2213
2214
5662
    if (ifilter->filter) {
2215
5662
        ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH);
2216
5662
        if (ret < 0)
2217
            return ret;
2218
    } else {
2219
        // the filtergraph was never configured
2220
        if (ifilter->format < 0)
2221
            ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
2222
        if (ifilter->format < 0 && (ifilter->type == AVMEDIA_TYPE_AUDIO || ifilter->type == AVMEDIA_TYPE_VIDEO)) {
2223
            av_log(NULL, AV_LOG_ERROR, "Cannot determine format of input stream %d:%d after EOF\n", ifilter->ist->file_index, ifilter->ist->st->index);
2224
            return AVERROR_INVALIDDATA;
2225
        }
2226
    }
2227
2228
5662
    return 0;
2229
}
2230
2231
// This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
2232
// There is the following difference: if you got a frame, you must call
2233
// it again with pkt=NULL. pkt==NULL is treated differently from pkt->size==0
2234
// (pkt==NULL means get more output, pkt->size==0 is a flush/drain packet)
2235
812339
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
2236
{
2237
    int ret;
2238
2239
812339
    *got_frame = 0;
2240
2241
812339
    if (pkt) {
2242
398367
        ret = avcodec_send_packet(avctx, pkt);
2243
        // In particular, we don't expect AVERROR(EAGAIN), because we read all
2244
        // decoded frames with avcodec_receive_frame() until done.
2245

398367
        if (ret < 0 && ret != AVERROR_EOF)
2246
379
            return ret;
2247
    }
2248
2249
811960
    ret = avcodec_receive_frame(avctx, frame);
2250

811960
    if (ret < 0 && ret != AVERROR(EAGAIN))
2251
5662
        return ret;
2252
806298
    if (ret >= 0)
2253
414645
        *got_frame = 1;
2254
2255
806298
    return 0;
2256
}
2257
2258
414645
static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
2259
{
2260
    int i, ret;
2261
    AVFrame *f;
2262
2263
    av_assert1(ist->nb_filters > 0); /* ensure ret is initialized */
2264
829678
    for (i = 0; i < ist->nb_filters; i++) {
2265
415033
        if (i < ist->nb_filters - 1) {
2266
388
            f = ist->filter_frame;
2267
388
            ret = av_frame_ref(f, decoded_frame);
2268
388
            if (ret < 0)
2269
                break;
2270
        } else
2271
414645
            f = decoded_frame;
2272
415033
        ret = ifilter_send_frame(ist->filters[i], f);
2273
415033
        if (ret == AVERROR_EOF)
2274
            ret = 0; /* ignore */
2275
415033
        if (ret < 0) {
2276
            av_log(NULL, AV_LOG_ERROR,
2277
                   "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2278
            break;
2279
        }
2280
    }
2281
414645
    return ret;
2282
}
2283
2284
605891
static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
2285
                        int *decode_failed)
2286
{
2287
    AVFrame *decoded_frame;
2288
605891
    AVCodecContext *avctx = ist->dec_ctx;
2289
605891
    int ret, err = 0;
2290
    AVRational decoded_frame_tb;
2291
2292

605891
    if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2293
        return AVERROR(ENOMEM);
2294

605891
    if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2295
        return AVERROR(ENOMEM);
2296
605891
    decoded_frame = ist->decoded_frame;
2297
2298
605891
    update_benchmark(NULL);
2299
605891
    ret = decode(avctx, decoded_frame, got_output, pkt);
2300
605891
    update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2301
605891
    if (ret < 0)
2302
1111
        *decode_failed = 1;
2303
2304

605891
    if (ret >= 0 && avctx->sample_rate <= 0) {
2305
        av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2306
        ret = AVERROR_INVALIDDATA;
2307
    }
2308
2309
605891
    if (ret != AVERROR_EOF)
2310
604790
        check_decode_result(ist, got_output, ret);
2311
2312

605891
    if (!*got_output || ret < 0)
2313
290109
        return ret;
2314
2315
315782
    ist->samples_decoded += decoded_frame->nb_samples;
2316
315782
    ist->frames_decoded++;
2317
2318
    /* increment next_dts to use for the case where the input stream does not
2319
       have timestamps or there are multiple frames in the packet */
2320
315782
    ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2321
315782
                     avctx->sample_rate;
2322
315782
    ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2323
315782
                     avctx->sample_rate;
2324
2325
315782
    if (decoded_frame->pts != AV_NOPTS_VALUE) {
2326
287622
        decoded_frame_tb   = ist->st->time_base;
2327

28160
    } else if (pkt && pkt->pts != AV_NOPTS_VALUE) {
2328
3
        decoded_frame->pts = pkt->pts;
2329
3
        decoded_frame_tb   = ist->st->time_base;
2330
    }else {
2331
28157
        decoded_frame->pts = ist->dts;
2332
28157
        decoded_frame_tb   = AV_TIME_BASE_Q;
2333
    }
2334
315782
    if (decoded_frame->pts != AV_NOPTS_VALUE)
2335
315782
        decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
2336
315782
                                              (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2337
315782
                                              (AVRational){1, avctx->sample_rate});
2338
315782
    ist->nb_samples = decoded_frame->nb_samples;
2339
315782
    err = send_frame_to_filters(ist, decoded_frame);
2340
2341
315782
    av_frame_unref(ist->filter_frame);
2342
315782
    av_frame_unref(decoded_frame);
2343
315782
    return err < 0 ? err : ret;
2344
}
2345
2346
207993
static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *duration_pts, int eof,
2347
                        int *decode_failed)
2348
{
2349
    AVFrame *decoded_frame;
2350
207993
    int i, ret = 0, err = 0;
2351
    int64_t best_effort_timestamp;
2352
207993
    int64_t dts = AV_NOPTS_VALUE;
2353
    AVPacket avpkt;
2354
2355
    // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
2356
    // reason. This seems like a semi-critical bug. Don't trigger EOF, and
2357
    // skip the packet.
2358

207993
    if (!eof && pkt && pkt->size == 0)
2359
1545
        return 0;
2360
2361

206448
    if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2362
        return AVERROR(ENOMEM);
2363

206448
    if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2364
        return AVERROR(ENOMEM);
2365
206448
    decoded_frame = ist->decoded_frame;
2366
206448
    if (ist->dts != AV_NOPTS_VALUE)
2367
206037
        dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2368
206448
    if (pkt) {
2369
108230
        avpkt = *pkt;
2370
108230
        avpkt.dts = dts; // ffmpeg.c probably shouldn't do this
2371
    }
2372
2373
    // The old code used to set dts on the drain packet, which does not work
2374
    // with the new API anymore.
2375
206448
    if (eof) {
2376
5201
        void *new = av_realloc_array(ist->dts_buffer, ist->nb_dts_buffer + 1, sizeof(ist->dts_buffer[0]));
2377
5201
        if (!new)
2378
            return AVERROR(ENOMEM);
2379
5201
        ist->dts_buffer = new;
2380
5201
        ist->dts_buffer[ist->nb_dts_buffer++] = dts;
2381
    }
2382
2383
206448
    update_benchmark(NULL);
2384
206448
    ret = decode(ist->dec_ctx, decoded_frame, got_output, pkt ? &avpkt : NULL);
2385
206448
    update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2386
206448
    if (ret < 0)
2387
4930
        *decode_failed = 1;
2388
2389
    // The following line may be required in some cases where there is no parser
2390
    // or the parser does not has_b_frames correctly
2391
206448
    if (ist->st->codecpar->video_delay < ist->dec_ctx->has_b_frames) {
2392
2
        if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2393
2
            ist->st->codecpar->video_delay = ist->dec_ctx->has_b_frames;
2394
        } else
2395
            av_log(ist->dec_ctx, AV_LOG_WARNING,
2396
                   "video_delay is larger in decoder than demuxer %d > %d.\n"
2397
                   "If you want to help, upload a sample "
2398
                   "of this file to ftp://upload.ffmpeg.org/incoming/ "
2399
                   "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
2400
                   ist->dec_ctx->has_b_frames,
2401
                   ist->st->codecpar->video_delay);
2402
    }
2403
2404
206448
    if (ret != AVERROR_EOF)
2405
201892
        check_decode_result(ist, got_output, ret);
2406
2407

206448
    if (*got_output && ret >= 0) {
2408
98863
        if (ist->dec_ctx->width  != decoded_frame->width ||
2409
98854
            ist->dec_ctx->height != decoded_frame->height ||
2410
98852
            ist->dec_ctx->pix_fmt != decoded_frame->format) {
2411
15
            av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2412
                decoded_frame->width,
2413
                decoded_frame->height,
2414
                decoded_frame->format,
2415
15
                ist->dec_ctx->width,
2416
15
                ist->dec_ctx->height,
2417
15
                ist->dec_ctx->pix_fmt);
2418
        }
2419
    }
2420
2421

206448
    if (!*got_output || ret < 0)
2422
107585
        return ret;
2423
2424
98863
    if(ist->top_field_first>=0)
2425
        decoded_frame->top_field_first = ist->top_field_first;
2426
2427
98863
    ist->frames_decoded++;
2428
2429

98863
    if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2430
        err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2431
        if (err < 0)
2432
            goto fail;
2433
    }
2434
98863
    ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2435
2436
98863
    best_effort_timestamp= decoded_frame->best_effort_timestamp;
2437
98863
    *duration_pts = decoded_frame->pkt_duration;
2438
2439
98863
    if (ist->framerate.num)
2440
103
        best_effort_timestamp = ist->cfr_next_pts++;
2441
2442

98863
    if (eof && best_effort_timestamp == AV_NOPTS_VALUE && ist->nb_dts_buffer > 0) {
2443
524
        best_effort_timestamp = ist->dts_buffer[0];
2444
2445
524
        for (i = 0; i < ist->nb_dts_buffer - 1; i++)
2446
            ist->dts_buffer[i] = ist->dts_buffer[i + 1];
2447
524
        ist->nb_dts_buffer--;
2448
    }
2449
2450
98863
    if(best_effort_timestamp != AV_NOPTS_VALUE) {
2451
98863
        int64_t ts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2452
2453
98863
        if (ts != AV_NOPTS_VALUE)
2454
98863
            ist->next_pts = ist->pts = ts;
2455
    }
2456
2457
98863
    if (debug_ts) {
2458
        av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2459
               "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d time_base:%d/%d\n",
2460
               ist->st->index, av_ts2str(decoded_frame->pts),
2461
               av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2462
               best_effort_timestamp,
2463
               av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2464
               decoded_frame->key_frame, decoded_frame->pict_type,
2465
               ist->st->time_base.num, ist->st->time_base.den);
2466
    }
2467
2468
98863
    if (ist->st->sample_aspect_ratio.num)
2469
4799
        decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2470
2471
98863
    err = send_frame_to_filters(ist, decoded_frame);
2472
2473
98863
fail:
2474
98863
    av_frame_unref(ist->filter_frame);
2475
98863
    av_frame_unref(decoded_frame);
2476
98863
    return err < 0 ? err : ret;
2477
}
2478
2479
1225
static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
2480
                               int *decode_failed)
2481
{
2482
    AVSubtitle subtitle;
2483
1225
    int free_sub = 1;
2484
1225
    int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2485
                                          &subtitle, got_output, pkt);
2486
2487
1225
    check_decode_result(NULL, got_output, ret);
2488
2489

1225
    if (ret < 0 || !*got_output) {
2490
585
        *decode_failed = 1;
2491
585
        if (!pkt->size)
2492
33
            sub2video_flush(ist);
2493
585
        return ret;
2494
    }
2495
2496
640
    if (ist->fix_sub_duration) {
2497
        int end = 1;
2498
        if (ist->prev_sub.got_output) {
2499
            end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2500
                             1000, AV_TIME_BASE);
2501
            if (end < ist->prev_sub.subtitle.end_display_time) {
2502
                av_log(ist->dec_ctx, AV_LOG_DEBUG,
2503
                       "Subtitle duration reduced from %"PRId32" to %d%s\n",
2504
                       ist->prev_sub.subtitle.end_display_time, end,
2505
                       end <= 0 ? ", dropping it" : "");
2506
                ist->prev_sub.subtitle.end_display_time = end;
2507
            }
2508
        }
2509
        FFSWAP(int,        *got_output, ist->prev_sub.got_output);
2510
        FFSWAP(int,        ret,         ist->prev_sub.ret);
2511
        FFSWAP(AVSubtitle, subtitle,    ist->prev_sub.subtitle);
2512
        if (end <= 0)
2513
            goto out;
2514
    }
2515
2516
640
    if (!*got_output)
2517
        return ret;
2518
2519
640
    if (ist->sub2video.frame) {
2520
88
        sub2video_update(ist, INT64_MIN, &subtitle);
2521
552
    } else if (ist->nb_filters) {
2522
        if (!ist->sub2video.sub_queue)
2523
            ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
2524
        if (!ist->sub2video.sub_queue)
2525
            exit_program(1);
2526
        if (!av_fifo_space(ist->sub2video.sub_queue)) {
2527
            ret = av_fifo_realloc2(ist->sub2video.sub_queue, 2 * av_fifo_size(ist->sub2video.sub_queue));
2528
            if (ret < 0)
2529
                exit_program(1);
2530
        }
2531
        av_fifo_generic_write(ist->sub2video.sub_queue, &subtitle, sizeof(subtitle), NULL);
2532
        free_sub = 0;
2533
    }
2534
2535
640
    if (!subtitle.num_rects)
2536
        goto out;
2537
2538
640
    ist->frames_decoded++;
2539
2540
1324
    for (i = 0; i < nb_output_streams; i++) {
2541
684
        OutputStream *ost = output_streams[i];
2542
2543

684
        if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2544
639
            || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2545
89
            continue;
2546
2547
595
        do_subtitle_out(output_files[ost->file_index], ost, &subtitle);
2548
    }
2549
2550
640
out:
2551
640
    if (free_sub)
2552
640
        avsubtitle_free(&subtitle);
2553
640
    return ret;
2554
}
2555
2556
5690
static int send_filter_eof(InputStream *ist)
2557
{
2558
    int i, ret;
2559
    /* TODO keep pts also in stream time base to avoid converting back */
2560
5690
    int64_t pts = av_rescale_q_rnd(ist->pts, AV_TIME_BASE_Q, ist->st->time_base,
2561
                                   AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
2562
2563
11352
    for (i = 0; i < ist->nb_filters; i++) {
2564
5662
        ret = ifilter_send_eof(ist->filters[i], pts);
2565
5662
        if (ret < 0)
2566
            return ret;
2567
    }
2568
5690
    return 0;
2569
}
2570
2571
/* pkt = NULL means EOF (needed to flush decoder buffers) */
2572
431978
static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
2573
{
2574
431978
    int ret = 0, i;
2575
431978
    int repeating = 0;
2576
431978
    int eof_reached = 0;
2577
2578
    AVPacket avpkt;
2579
431978
    if (!ist->saw_first_ts) {
2580
6022
        ist->dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2581
6022
        ist->pts = 0;
2582

6022
        if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2583
211
            ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2584
211
            ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2585
        }
2586
6022
        ist->saw_first_ts = 1;
2587
    }
2588
2589
431978
    if (ist->next_dts == AV_NOPTS_VALUE)
2590
6436
        ist->next_dts = ist->dts;
2591
431978
    if (ist->next_pts == AV_NOPTS_VALUE)
2592
6022
        ist->next_pts = ist->pts;
2593
2594
431978
    if (!pkt) {
2595
        /* EOF handling */
2596
6428
        av_init_packet(&avpkt);
2597
6428
        avpkt.data = NULL;
2598
6428
        avpkt.size = 0;
2599
    } else {
2600
425550
        avpkt = *pkt;
2601
    }
2602
2603

431978
    if (pkt && pkt->dts != AV_NOPTS_VALUE) {
2604
388835
        ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2605

388835
        if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2606
314439
            ist->next_pts = ist->pts = ist->dts;
2607
    }
2608
2609
    // while we have more to decode or while the decoder did output something on EOF
2610
846590
    while (ist->decoding_needed) {
2611
815749
        int64_t duration_dts = 0;
2612
815749
        int64_t duration_pts = 0;
2613
815749
        int got_output = 0;
2614
815749
        int decode_failed = 0;
2615
2616
815749
        ist->pts = ist->next_pts;
2617
815749
        ist->dts = ist->next_dts;
2618
2619

815749
        switch (ist->dec_ctx->codec_type) {
2620
605891
        case AVMEDIA_TYPE_AUDIO:
2621
605891
            ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
2622
                                   &decode_failed);
2623
605891
            break;
2624
207993
        case AVMEDIA_TYPE_VIDEO:
2625
207993
            ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, &duration_pts, !pkt,
2626
                                   &decode_failed);
2627

207993
            if (!repeating || !pkt || got_output) {
2628

109775
                if (pkt && pkt->duration) {
2629
102284
                    duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2630

7491
                } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2631
6254
                    int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
2632
6254
                    duration_dts = ((int64_t)AV_TIME_BASE *
2633
6254
                                    ist->dec_ctx->framerate.den * ticks) /
2634
6254
                                    ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2635
                }
2636
2637

109775
                if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
2638
108538
                    ist->next_dts += duration_dts;
2639
                }else
2640
1237
                    ist->next_dts = AV_NOPTS_VALUE;
2641
            }
2642
2643
207993
            if (got_output) {
2644
98863
                if (duration_pts > 0) {
2645
96575
                    ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
2646
                } else {
2647
2288
                    ist->next_pts += duration_dts;
2648
                }
2649
            }
2650
207993
            break;
2651
1865
        case AVMEDIA_TYPE_SUBTITLE:
2652
1865
            if (repeating)
2653
640
                break;
2654
1225
            ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
2655

1225
            if (!pkt && ret >= 0)
2656
33
                ret = AVERROR_EOF;
2657
1225
            break;
2658
        default:
2659
            return -1;
2660
        }
2661
2662
815749
        if (ret == AVERROR_EOF) {
2663
5690
            eof_reached = 1;
2664
401137
            break;
2665
        }
2666
2667
810059
        if (ret < 0) {
2668
463
            if (decode_failed) {
2669
926
                av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2670
463
                       ist->file_index, ist->st->index, av_err2str(ret));
2671
            } else {
2672
                av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
2673
                       "data for stream #%d:%d\n", ist->file_index, ist->st->index);
2674
            }
2675

463
            if (!decode_failed || exit_on_error)
2676
                exit_program(1);
2677
463
            break;
2678
        }
2679
2680
809596
        if (got_output)
2681
415285
            ist->got_output = 1;
2682
2683
809596
        if (!got_output)
2684
394311
            break;
2685
2686
        // During draining, we might get multiple output frames in this loop.
2687
        // ffmpeg.c does not drain the filter chain on configuration changes,
2688
        // which means if we send multiple frames at once to the filters, and
2689
        // one of those frames changes configuration, the buffered frames will
2690
        // be lost. This can upset certain FATE tests.
2691
        // Decode only 1 frame per call on EOF to appease these FATE tests.
2692
        // The ideal solution would be to rewrite decoding to use the new
2693
        // decoding API in a better way.
2694
415285
        if (!pkt)
2695
673
            break;
2696
2697
414612
        repeating = 1;
2698
    }
2699
2700
    /* after flushing, send an EOF on all the filter inputs attached to the stream */
2701
    /* except when looping we need to flush but not to send an EOF */
2702


431978
    if (!pkt && ist->decoding_needed && eof_reached && !no_eof) {
2703
5690
        int ret = send_filter_eof(ist);
2704
5690
        if (ret < 0) {
2705
            av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2706
            exit_program(1);
2707
        }
2708
    }
2709
2710
    /* handle stream copy */
2711

431978
    if (!ist->decoding_needed && pkt) {
2712
30777
        ist->dts = ist->next_dts;
2713
30777
        switch (ist->dec_ctx->codec_type) {
2714
20301
        case AVMEDIA_TYPE_AUDIO:
2715
            av_assert1(pkt->duration >= 0);
2716
20301
            if (ist->dec_ctx->sample_rate) {
2717
20301
                ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2718
20301
                                  ist->dec_ctx->sample_rate;
2719
            } else {
2720
                ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2721
            }
2722
20301
            break;
2723
9945
        case AVMEDIA_TYPE_VIDEO:
2724
9945
            if (ist->framerate.num) {
2725
                // TODO: Remove work-around for c99-to-c89 issue 7
2726
79
                AVRational time_base_q = AV_TIME_BASE_Q;
2727
79
                int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2728
79
                ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2729
9866
            } else if (pkt->duration) {
2730
9463
                ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2731
403
            } else if(ist->dec_ctx->framerate.num != 0) {
2732
276
                int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2733
276
                ist->next_dts += ((int64_t)AV_TIME_BASE *
2734
276
                                  ist->dec_ctx->framerate.den * ticks) /
2735
276
                                  ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2736
            }
2737
9945
            break;
2738
        }
2739
30777
        ist->pts = ist->dts;
2740
30777
        ist->next_pts = ist->next_dts;
2741
    }
2742
877883
    for (i = 0; i < nb_output_streams; i++) {
2743
445905
        OutputStream *ost = output_streams[i];
2744
2745

445905
        if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2746
415151
            continue;
2747
2748
30754
        do_streamcopy(ist, ost, pkt);
2749
    }
2750
2751
431978
    return !eof_reached;
2752
}
2753
2754
static void print_sdp(void)
2755
{
2756
    char sdp[16384];
2757
    int i;
2758
    int j;
2759
    AVIOContext *sdp_pb;
2760
    AVFormatContext **avc;
2761
2762
    for (i = 0; i < nb_output_files; i++) {
2763
        if (!output_files[i]->header_written)
2764
            return;
2765
    }
2766
2767
    avc = av_malloc_array(nb_output_files, sizeof(*avc));
2768
    if (!avc)
2769
        exit_program(1);
2770
    for (i = 0, j = 0; i < nb_output_files; i++) {
2771
        if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
2772
            avc[j] = output_files[i]->ctx;
2773
            j++;
2774
        }
2775
    }
2776
2777
    if (!j)
2778
        goto fail;
2779
2780
    av_sdp_create(avc, j, sdp, sizeof(sdp));
2781
2782
    if (!sdp_filename) {
2783
        printf("SDP:\n%s\n", sdp);
2784
        fflush(stdout);
2785
    } else {
2786
        if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
2787
            av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
2788
        } else {
2789
            avio_print(sdp_pb, sdp);
2790
            avio_closep(&sdp_pb);
2791
            av_freep(&sdp_filename);
2792
        }
2793
    }
2794
2795
fail:
2796
    av_freep(&avc);
2797
}
2798
2799
926
static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
2800
{
2801
926
    InputStream *ist = s->opaque;
2802
    const enum AVPixelFormat *p;
2803
    int ret;
2804
2805
2521
    for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
2806
2521
        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
2807
2521
        const AVCodecHWConfig  *config = NULL;
2808
        int i;
2809
2810
2521
        if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
2811
926
            break;
2812
2813
1595
        if (ist->hwaccel_id == HWACCEL_GENERIC ||
2814
1595
            ist->hwaccel_id == HWACCEL_AUTO) {
2815
            for (i = 0;; i++) {
2816
                config = avcodec_get_hw_config(s->codec, i);
2817
                if (!config)
2818
                    break;
2819
                if (!(config->methods &
2820
                      AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
2821
                    continue;
2822
                if (config->pix_fmt == *p)
2823
                    break;
2824
            }
2825
        }
2826
1595
        if (config) {
2827
            if (config->device_type != ist->hwaccel_device_type) {
2828
                // Different hwaccel offered, ignore.
2829
                continue;
2830
            }
2831
2832
            ret = hwaccel_decode_init(s);
2833
            if (ret < 0) {
2834
                if (ist->hwaccel_id == HWACCEL_GENERIC) {
2835
                    av_log(NULL, AV_LOG_FATAL,
2836
                           "%s hwaccel requested for input stream #%d:%d, "
2837
                           "but cannot be initialized.\n",
2838
                           av_hwdevice_get_type_name(config->device_type),
2839
                           ist->file_index, ist->st->index);
2840
                    return AV_PIX_FMT_NONE;
2841
                }
2842
                continue;
2843
            }
2844
        } else {
2845
1595
            const HWAccel *hwaccel = NULL;
2846
            int i;
2847
1595
            for (i = 0; hwaccels[i].name; i++) {
2848
                if (hwaccels[i].pix_fmt == *p) {
2849
                    hwaccel = &hwaccels[i];
2850
                    break;
2851
                }
2852
            }
2853
1595
            if (!hwaccel) {
2854
                // No hwaccel supporting this pixfmt.
2855
1595
                continue;
2856
            }
2857
            if (hwaccel->id != ist->hwaccel_id) {
2858
                // Does not match requested hwaccel.
2859
                continue;
2860
            }
2861
2862
            ret = hwaccel->init(s);
2863
            if (ret < 0) {
2864
                av_log(NULL, AV_LOG_FATAL,
2865
                       "%s hwaccel requested for input stream #%d:%d, "
2866
                       "but cannot be initialized.\n", hwaccel->name,
2867
                       ist->file_index, ist->st->index);
2868
                return AV_PIX_FMT_NONE;
2869
            }
2870
        }
2871
2872
        if (ist->hw_frames_ctx) {
2873
            s->hw_frames_ctx = av_buffer_ref(ist->hw_frames_ctx);
2874
            if (!s->hw_frames_ctx)
2875
                return AV_PIX_FMT_NONE;
2876
        }
2877
2878
        ist->hwaccel_pix_fmt = *p;
2879
        break;
2880
    }
2881
2882
926
    return *p;
2883
}
2884
2885
389640
static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
2886
{
2887
389640
    InputStream *ist = s->opaque;
2888
2889

389640
    if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
2890
        return ist->hwaccel_get_buffer(s, frame, flags);
2891
2892
389640
    return avcodec_default_get_buffer2(s, frame, flags);
2893
}
2894
2895
6220
static int init_input_stream(int ist_index, char *error, int error_len)
2896
{
2897
    int ret;
2898
6220
    InputStream *ist = input_streams[ist_index];
2899
2900
6220
    if (ist->decoding_needed) {
2901
5702
        AVCodec *codec = ist->dec;
2902
5702
        if (!codec) {
2903
            snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2904
                    avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
2905
            return AVERROR(EINVAL);
2906
        }
2907
2908
5702
        ist->dec_ctx->opaque                = ist;
2909
5702
        ist->dec_ctx->get_format            = get_format;
2910
5702
        ist->dec_ctx->get_buffer2           = get_buffer;
2911
5702
        ist->dec_ctx->thread_safe_callbacks = 1;
2912
2913
5702
        av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
2914
5702
        if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
2915
           (ist->decoding_needed & DECODING_FOR_OST)) {
2916
            av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
2917
            if (ist->decoding_needed & DECODING_FOR_FILTER)
2918
                av_log(NULL, AV_LOG_WARNING, "Warning using DVB subtitles for filtering and output at the same time is not fully supported, also see -compute_edt [0|1]\n");
2919
        }
2920
2921
5702
        av_dict_set(&ist->decoder_opts, "sub_text_format", "ass", AV_DICT_DONT_OVERWRITE);
2922
2923
        /* Useful for subtitles retiming by lavf (FIXME), skipping samples in
2924
         * audio, and video decoders such as cuvid or mediacodec */
2925
5702
        ist->dec_ctx->pkt_timebase = ist->st->time_base;
2926
2927
5702
        if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
2928
53
            av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
2929
        /* Attached pics are sparse, therefore we would not want to delay their decoding till EOF. */
2930
5702
        if (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2931
1
            av_dict_set(&ist->decoder_opts, "threads", "1", 0);
2932
2933
5702
        ret = hw_device_setup_for_decode(ist);
2934
5702
        if (ret < 0) {
2935
            snprintf(error, error_len, "Device setup failed for "
2936
                     "decoder on input stream #%d:%d : %s",
2937
                     ist->file_index, ist->st->index, av_err2str(ret));
2938
            return ret;
2939
        }
2940
2941
5702
        if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
2942
            if (ret == AVERROR_EXPERIMENTAL)
2943
                abort_codec_experimental(codec, 0);
2944
2945
            snprintf(error, error_len,
2946
                     "Error while opening decoder for input stream "
2947
                     "#%d:%d : %s",
2948
                     ist->file_index, ist->st->index, av_err2str(ret));
2949
            return ret;
2950
        }
2951
5702
        assert_avoptions(ist->decoder_opts);
2952
    }
2953
2954
6220
    ist->next_pts = AV_NOPTS_VALUE;
2955
6220
    ist->next_dts = AV_NOPTS_VALUE;
2956
2957
6220
    return 0;
2958
}
2959
2960
17429
static InputStream *get_input_stream(OutputStream *ost)
2961
{
2962
17429
    if (ost->source_index >= 0)
2963
17252
        return input_streams[ost->source_index];
2964
177
    return NULL;
2965
}
2966
2967
1
static int compare_int64(const void *a, const void *b)
2968
{
2969
1
    return FFDIFFSIGN(*(const int64_t *)a, *(const int64_t *)b);
2970
}
2971
2972
/* open the muxer when all the streams are initialized */
2973
6015
static int check_init_output_file(OutputFile *of, int file_index)
2974
{
2975
    int ret, i;
2976
2977
12148
    for (i = 0; i < of->ctx->nb_streams; i++) {
2978
6277
        OutputStream *ost = output_streams[of->ost_index + i];
2979
6277
        if (!ost->initialized)
2980
144
            return 0;
2981
    }
2982
2983
5871
    of->ctx->interrupt_callback = int_cb;
2984
2985
5871
    ret = avformat_write_header(of->ctx, &of->opts);
2986
5871
    if (ret < 0) {
2987
        av_log(NULL, AV_LOG_ERROR,
2988
               "Could not write header for output file #%d "
2989
               "(incorrect codec parameters ?): %s\n",
2990
               file_index, av_err2str(ret));
2991
        return ret;
2992
    }
2993
    //assert_avoptions(of->opts);
2994
5871
    of->header_written = 1;
2995
2996
5871
    av_dump_format(of->ctx, file_index, of->ctx->url, 1);
2997
2998

5871
    if (sdp_filename || want_sdp)
2999
        print_sdp();
3000
3001
    /* flush the muxing queues */
3002
11885
    for (i = 0; i < of->ctx->nb_streams; i++) {
3003
6014
        OutputStream *ost = output_streams[of->ost_index + i];
3004
3005
        /* try to improve muxing time_base (only possible if nothing has been written yet) */
3006
6014
        if (!av_fifo_size(ost->muxing_queue))
3007
5937
            ost->mux_timebase = ost->st->time_base;
3008
3009
6291
        while (av_fifo_size(ost->muxing_queue)) {
3010
            AVPacket pkt;
3011
277
            av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
3012
277
            write_packet(of, &pkt, ost, 1);
3013
        }
3014
    }
3015
3016
5871
    return 0;
3017
}
3018
3019
6014
static int init_output_bsfs(OutputStream *ost)
3020
{
3021
    AVBSFContext *ctx;
3022
    int i, ret;
3023
3024
6014
    if (!ost->nb_bitstream_filters)
3025
5930
        return 0;
3026
3027
168
    for (i = 0; i < ost->nb_bitstream_filters; i++) {
3028
84
        ctx = ost->bsf_ctx[i];
3029
3030
168
        ret = avcodec_parameters_copy(ctx->par_in,
3031
84
                                      i ? ost->bsf_ctx[i - 1]->par_out : ost->st->codecpar);
3032
84
        if (ret < 0)
3033
            return ret;
3034
3035
84
        ctx->time_base_in = i ? ost->bsf_ctx[i - 1]->time_base_out : ost->st->time_base;
3036
3037
84
        ret = av_bsf_init(ctx);
3038
84
        if (ret < 0) {
3039
            av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
3040
                   ost->bsf_ctx[i]->filter->name);
3041
            return ret;
3042
        }
3043
    }
3044
3045
84
    ctx = ost->bsf_ctx[ost->nb_bitstream_filters - 1];
3046
84
    ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
3047
84
    if (ret < 0)
3048
        return ret;
3049
3050
84
    ost->st->time_base = ctx->time_base_out;
3051
3052
84
    return 0;
3053
}
3054
3055
290
static int init_output_stream_streamcopy(OutputStream *ost)
3056
{
3057
290
    OutputFile *of = output_files[ost->file_index];
3058
290
    InputStream *ist = get_input_stream(ost);
3059
290
    AVCodecParameters *par_dst = ost->st->codecpar;
3060
290
    AVCodecParameters *par_src = ost->ref_par;
3061
    AVRational sar;
3062
    int i, ret;
3063
290
    uint32_t codec_tag = par_dst->codec_tag;
3064
3065

290
    av_assert0(ist && !ost->filter);
3066
3067
290
    ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
3068
290
    if (ret >= 0)
3069
290
        ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
3070
290
    if (ret < 0) {
3071
        av_log(NULL, AV_LOG_FATAL,
3072
               "Error setting up codec context options.\n");
3073
        return ret;
3074
    }
3075
3076
290
    ret = avcodec_parameters_from_context(par_src, ost->enc_ctx);
3077
290
    if (ret < 0) {
3078
        av_log(NULL, AV_LOG_FATAL,
3079
               "Error getting reference codec parameters.\n");
3080
        return ret;
3081
    }
3082
3083
290
    if (!codec_tag) {
3084
        unsigned int codec_tag_tmp;
3085
284
        if (!of->ctx->oformat->codec_tag ||
3086

71
            av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
3087
26
            !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag_tmp))
3088
261
            codec_tag = par_src->codec_tag;
3089
    }
3090
3091
290
    ret = avcodec_parameters_copy(par_dst, par_src);
3092
290
    if (ret < 0)
3093
        return ret;
3094
3095
290
    par_dst->codec_tag = codec_tag;
3096
3097
290
    if (!ost->frame_rate.num)
3098
289
        ost->frame_rate = ist->framerate;
3099
290
    ost->st->avg_frame_rate = ost->frame_rate;
3100
3101
290
    ret = avformat_transfer_internal_stream_timing_info(of->ctx->oformat, ost->st, ist->st, copy_tb);
3102
290
    if (ret < 0)
3103
        return ret;
3104
3105
    // copy timebase while removing common factors
3106

290
    if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3107
289
        ost->st->time_base = av_add_q(av_stream_get_codec_timebase(ost->st), (AVRational){0, 1});
3108
3109
    // copy estimated duration as a hint to the muxer
3110

290
    if (ost->st->duration <= 0 && ist->st->duration > 0)
3111
172
        ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3112
3113
    // copy disposition
3114
290
    ost->st->disposition = ist->st->disposition;
3115
3116
290
    if (ist->st->nb_side_data) {
3117
46
        for (i = 0; i < ist->st->nb_side_data; i++) {
3118
23
            const AVPacketSideData *sd_src = &ist->st->side_data[i];
3119
            uint8_t *dst_data;
3120
3121
23
            dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3122
23
            if (!dst_data)
3123
                return AVERROR(ENOMEM);
3124
23
            memcpy(dst_data, sd_src->data, sd_src->size);
3125
        }
3126
    }
3127
3128
290
    if (ost->rotate_overridden) {
3129
1
        uint8_t *sd = av_stream_new_side_data(ost->st, AV_PKT_DATA_DISPLAYMATRIX,
3130
                                              sizeof(int32_t) * 9);
3131
1
        if (sd)
3132
1
            av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
3133
    }
3134
3135
290
    switch (par_dst->codec_type) {
3136
102
    case AVMEDIA_TYPE_AUDIO:
3137
102
        if (audio_volume != 256) {
3138
            av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3139
            exit_program(1);
3140
        }
3141


102
        if((par_dst->block_align == 1 || par_dst->block_align == 1152 || par_dst->block_align == 576) && par_dst->codec_id == AV_CODEC_ID_MP3)
3142
            par_dst->block_align= 0;
3143
102
        if(par_dst->codec_id == AV_CODEC_ID_AC3)
3144
2
            par_dst->block_align= 0;
3145
102
        break;
3146
171
    case AVMEDIA_TYPE_VIDEO:
3147
171
        if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
3148
            sar =
3149
                av_mul_q(ost->frame_aspect_ratio,
3150
                         (AVRational){ par_dst->height, par_dst->width });
3151
            av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
3152
                   "with stream copy may produce invalid files\n");
3153
            }
3154
171
        else if (ist->st->sample_aspect_ratio.num)
3155
54
            sar = ist->st->sample_aspect_ratio;
3156
        else
3157
117
            sar = par_src->sample_aspect_ratio;
3158
171
        ost->st->sample_aspect_ratio = par_dst->sample_aspect_ratio = sar;
3159
171
        ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3160
171
        ost->st->r_frame_rate = ist->st->r_frame_rate;
3161
171
        break;
3162
    }
3163
3164
290
    ost->mux_timebase = ist->st->time_base;
3165
3166
290
    return 0;
3167
}
3168
3169
5723
static void set_encoder_id(OutputFile *of, OutputStream *ost)
3170
{
3171
    AVDictionaryEntry *e;
3172
3173
    uint8_t *encoder_string;
3174
    int encoder_string_len;
3175
5723
    int format_flags = 0;
3176
5723
    int codec_flags = ost->enc_ctx->flags;
3177
3178
5723
    if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
3179
        return;
3180
3181
5723
    e = av_dict_get(of->opts, "fflags", NULL, 0);
3182
5723
    if (e) {
3183
3316
        const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
3184
3316
        if (!o)
3185
            return;
3186
3316
        av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
3187
    }
3188
5723
    e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
3189
5723
    if (e) {
3190
3307
        const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
3191
3307
        if (!o)
3192
            return;
3193
3307
        av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
3194
    }
3195
3196
5723
    encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
3197
5723
    encoder_string     = av_mallocz(encoder_string_len);
3198
5723
    if (!encoder_string)
3199
        exit_program(1);
3200
3201

5723
    if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
3202
825
        av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
3203
    else
3204
4898
        av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
3205
5723
    av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
3206
5723
    av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
3207
                AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
3208
}
3209
3210
1
static void parse_forced_key_frames(char *kf, OutputStream *ost,
3211
                                    AVCodecContext *avctx)
3212
{
3213
    char *p;
3214
1
    int n = 1, i, size, index = 0;
3215
    int64_t t, *pts;
3216
3217
14
    for (p = kf; *p; p++)
3218
13
        if (*p == ',')
3219
1
            n++;
3220
1
    size = n;
3221
1
    pts = av_malloc_array(size, sizeof(*pts));
3222
1
    if (!pts) {
3223
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3224
        exit_program(1);
3225
    }
3226
3227
1
    p = kf;
3228
3
    for (i = 0; i < n; i++) {
3229
2
        char *next = strchr(p, ',');
3230
3231
2
        if (next)
3232
1
            *next++ = 0;
3233
3234
2
        if (!memcmp(p, "chapters", 8)) {
3235
3236
            AVFormatContext *avf = output_files[ost->file_index]->ctx;
3237
            int j;
3238
3239
            if (avf->nb_chapters > INT_MAX - size ||
3240
                !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
3241
                                     sizeof(*pts)))) {
3242
                av_log(NULL, AV_LOG_FATAL,
3243
                       "Could not allocate forced key frames array.\n");
3244
                exit_program(1);
3245
            }
3246
            t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
3247
            t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3248
3249
            for (j = 0; j < avf->nb_chapters; j++) {
3250
                AVChapter *c = avf->chapters[j];
3251
                av_assert1(index < size);
3252
                pts[index++] = av_rescale_q(c->start, c->time_base,
3253
                                            avctx->time_base) + t;
3254
            }
3255
3256
        } else {
3257
3258
2
            t = parse_time_or_die("force_key_frames", p, 1);
3259
            av_assert1(index < size);
3260
2
            pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3261
3262
        }
3263
3264
2
        p = next;
3265
    }
3266
3267
1
    av_assert0(index == size);
3268
1
    qsort(pts, size, sizeof(*pts), compare_int64);
3269
1
    ost->forced_kf_count = size;
3270
1
    ost->forced_kf_pts   = pts;
3271
1
}
3272
3273
5693
static void init_encoder_time_base(OutputStream *ost, AVRational default_time_base)
3274
{
3275
5693
    InputStream *ist = get_input_stream(ost);
3276
5693
    AVCodecContext *enc_ctx = ost->enc_ctx;
3277
    AVFormatContext *oc;
3278
3279
5693
    if (ost->enc_timebase.num > 0) {
3280
        enc_ctx->time_base = ost->enc_timebase;
3281
        return;
3282
    }
3283
3284
5693
    if (ost->enc_timebase.num < 0) {
3285
        if (ist) {
3286
            enc_ctx->time_base = ist->st->time_base;
3287
            return;
3288
        }
3289
3290
        oc = output_files[ost->file_index]->ctx;
3291
        av_log(oc, AV_LOG_WARNING, "Input stream data not available, using default time base\n");
3292
    }
3293
3294
5693
    enc_ctx->time_base = default_time_base;
3295
}
3296
3297
5723
static int init_output_stream_encode(OutputStream *ost)
3298
{
3299
5723
    InputStream *ist = get_input_stream(ost);
3300
5723
    AVCodecContext *enc_ctx = ost->enc_ctx;
3301
5723
    AVCodecContext *dec_ctx = NULL;
3302
5723
    AVFormatContext *oc = output_files[ost->file_index]->ctx;
3303
    int j, ret;
3304
3305
5723
    set_encoder_id(output_files[ost->file_index], ost);
3306
3307
    // Muxers use AV_PKT_DATA_DISPLAYMATRIX to signal rotation. On the other
3308
    // hand, the legacy API makes demuxers set "rotate" metadata entries,
3309
    // which have to be filtered out to prevent leaking them to output files.
3310
5723
    av_dict_set(&ost->st->metadata, "rotate", NULL, 0);
3311
3312
5723
    if (ist) {
3313
5664
        ost->st->disposition          = ist->st->disposition;
3314
3315
5664
        dec_ctx = ist->dec_ctx;
3316
3317
5664
        enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
3318
    } else {
3319
124
        for (j = 0; j < oc->nb_streams; j++) {
3320
65
            AVStream *st = oc->streams[j];
3321

65
            if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
3322
                break;
3323
        }
3324
59
        if (j == oc->nb_streams)
3325
59
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
3326
50
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3327
59
                ost->st->disposition = AV_DISPOSITION_DEFAULT;
3328
    }
3329
3330
5723
    if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3331
4593
        if (!ost->frame_rate.num)
3332
4573
            ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3333

4593
        if (ist && !ost->frame_rate.num)
3334
2
            ost->frame_rate = ist->framerate;
3335

4593
        if (ist && !ost->frame_rate.num)
3336
2
            ost->frame_rate = ist->st->r_frame_rate;
3337

4593
        if (ist && !ost->frame_rate.num) {
3338
2
            ost->frame_rate = (AVRational){25, 1};
3339
2
            av_log(NULL, AV_LOG_WARNING,
3340
                   "No information "
3341
                   "about the input framerate is available. Falling "
3342
                   "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3343
                   "if you want a different framerate.\n",
3344
                   ost->file_index, ost->index);
3345
        }
3346
3347

4593
        if (ost->enc->supported_framerates && !ost->force_fps) {
3348
48
            int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3349
48
            ost->frame_rate = ost->enc->supported_framerates[idx];
3350
        }
3351
        // reduce frame rate for mpeg4 to be within the spec limits
3352
4593
        if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3353
58
            av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3354
58
                      ost->frame_rate.num, ost->frame_rate.den, 65535);
3355
        }
3356
    }
3357
3358

5723
    switch (enc_ctx->codec_type) {
3359
1100