GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg.c Lines: 2021 2765 73.1 %
Date: 2019-11-22 03:34:36 Branches: 1479 2159 68.5 %

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
90
static int sub2video_get_blank_frame(InputStream *ist)
177
{
178
    int ret;
179
90
    AVFrame *frame = ist->sub2video.frame;
180
181
90
    av_frame_unref(frame);
182
90
    ist->sub2video.frame->width  = ist->dec_ctx->width  ? ist->dec_ctx->width  : ist->sub2video.w;
183
90
    ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
184
90
    ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
185
90
    if ((ret = av_frame_get_buffer(frame, 32)) < 0)
186
        return ret;
187
90
    memset(frame->data[0], 0, frame->height * frame->linesize[0]);
188
90
    return 0;
189
}
190
191
44
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
44
    if (r->type != SUBTITLE_BITMAP) {
199
        av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
200
        return;
201
    }
202


44
    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
44
    dst += r->y * dst_linesize + r->x * 4;
210
44
    src = r->data[0];
211
44
    pal = (uint32_t *)r->data[1];
212
1642
    for (y = 0; y < r->h; y++) {
213
1598
        dst2 = (uint32_t *)dst;
214
1598
        src2 = src;
215
480325
        for (x = 0; x < r->w; x++)
216
478727
            *(dst2++) = pal[*(src2++)];
217
1598
        dst += dst_linesize;
218
1598
        src += r->linesize[0];
219
    }
220
}
221
222
337
static void sub2video_push_ref(InputStream *ist, int64_t pts)
223
{
224
337
    AVFrame *frame = ist->sub2video.frame;
225
    int i;
226
    int ret;
227
228
    av_assert1(frame->data[0]);
229
337
    ist->sub2video.last_pts = frame->pts = pts;
230
674
    for (i = 0; i < ist->nb_filters; i++) {
231
337
        ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
232
                                           AV_BUFFERSRC_FLAG_KEEP_REF |
233
                                           AV_BUFFERSRC_FLAG_PUSH);
234

337
        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
337
}
239
240
119
void sub2video_update(InputStream *ist, AVSubtitle *sub)
241
{
242
119
    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
119
    if (!frame)
249
29
        return;
250
90
    if (sub) {
251
44
        pts       = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
252
44
                                 AV_TIME_BASE_Q, ist->st->time_base);
253
44
        end_pts   = av_rescale_q(sub->pts + sub->end_display_time   * 1000LL,
254
44
                                 AV_TIME_BASE_Q, ist->st->time_base);
255
44
        num_rects = sub->num_rects;
256
    } else {
257
46
        pts       = ist->sub2video.end_pts;
258
46
        end_pts   = INT64_MAX;
259
46
        num_rects = 0;
260
    }
261
90
    if (sub2video_get_blank_frame(ist) < 0) {
262
        av_log(ist->dec_ctx, AV_LOG_ERROR,
263
               "Impossible to get a blank canvas.\n");
264
        return;
265
    }
266
90
    dst          = frame->data    [0];
267
90
    dst_linesize = frame->linesize[0];
268
134
    for (i = 0; i < num_rects; i++)
269
44
        sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
270
90
    sub2video_push_ref(ist, pts);
271
90
    ist->sub2video.end_pts = end_pts;
272
}
273
274
402289
static void sub2video_heartbeat(InputStream *ist, int64_t pts)
275
{
276
402289
    InputFile *infile = input_files[ist->file_index];
277
    int i, j, nb_reqs;
278
    int64_t pts2;
279
280
    /* When a frame is read from a file, examine all sub2video streams in
281
       the same file and send the sub2video frame again. Otherwise, decoded
282
       video frames could be accumulating in the filter graph while a filter
283
       (possibly overlay) is desperately waiting for a subtitle frame. */
284
843313
    for (i = 0; i < infile->nb_streams; i++) {
285
441024
        InputStream *ist2 = input_streams[infile->ist_index + i];
286
441024
        if (!ist2->sub2video.frame)
287
440135
            continue;
288
        /* subtitles seem to be usually muxed ahead of other streams;
289
           if not, subtracting a larger time here is necessary */
290
889
        pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
291
        /* do not send the heartbeat frame if the subtitle is already ahead */
292
889
        if (pts2 <= ist2->sub2video.last_pts)
293
            continue;
294
889
        if (pts2 >= ist2->sub2video.end_pts ||
295

845
            (!ist2->sub2video.frame->data[0] && ist2->sub2video.end_pts < INT64_MAX))
296
44
            sub2video_update(ist2, NULL);
297
1778
        for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
298
889
            nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
299
889
        if (nb_reqs)
300
247
            sub2video_push_ref(ist2, pts2);
301
    }
302
402289
}
303
304
31
static void sub2video_flush(InputStream *ist)
305
{
306
    int i;
307
    int ret;
308
309
31
    if (ist->sub2video.end_pts < INT64_MAX)
310
31
        sub2video_update(ist, NULL);
311
33
    for (i = 0; i < ist->nb_filters; i++) {
312
2
        ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
313

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

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

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

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

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

429808
    if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
737

406480
        (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
738
23328
        pkt->pts = pkt->dts = AV_NOPTS_VALUE;
739
740
429808
    if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
741
        int i;
742
107980
        uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
743
                                              NULL);
744
107980
        ost->quality = sd ? AV_RL32(sd) : -1;
745
107980
        ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
746
747
539900
        for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
748

431920
            if (sd && i < sd[5])
749
                ost->error[i] = AV_RL64(sd + 8 + 8*i);
750
            else
751
431920
                ost->error[i] = -1;
752
        }
753
754

107980
        if (ost->frame_rate.num && ost->is_cfr) {
755
9789
            if (pkt->duration > 0)
756
                av_log(NULL, AV_LOG_WARNING, "Overriding packet duration by frame rate, this should not happen\n");
757
9789
            pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
758
                                         ost->mux_timebase);
759
        }
760
    }
761
762
429808
    av_packet_rescale_ts(pkt, ost->mux_timebase, ost->st->time_base);
763
764
429808
    if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
765
190133
        if (pkt->dts != AV_NOPTS_VALUE &&
766
166805
            pkt->pts != AV_NOPTS_VALUE &&
767
166286
            pkt->dts > pkt->pts) {
768
            av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
769
                   pkt->dts, pkt->pts,
770
                   ost->file_index, ost->st->index);
771
            pkt->pts =
772
            pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1
773
                     - FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)
774
                     - FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);
775
        }
776

190133
        if ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO || st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) &&
777
190120
            pkt->dts != AV_NOPTS_VALUE &&
778

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

434805
    if (ret < 0 && ret != AVERROR_EOF) {
891
1
        av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
892
               "packet for stream #%d:%d.\n", ost->file_index, ost->index);
893
1
        if(exit_on_error)
894
            exit_program(1);
895
    }
896
434805
}
897
898
406628
static int check_recording_time(OutputStream *ost)
899
{
900
406628
    OutputFile *of = output_files[ost->file_index];
901
902

414088
    if (of->recording_time != INT64_MAX &&
903
7460
        av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
904
7460
                      AV_TIME_BASE_Q) >= 0) {
905
1
        close_output_stream(ost);
906
1
        return 0;
907
    }
908
406627
    return 1;
909
}
910
911
306974
static void do_audio_out(OutputFile *of, OutputStream *ost,
912
                         AVFrame *frame)
913
{
914
306974
    AVCodecContext *enc = ost->enc_ctx;
915
    AVPacket pkt;
916
    int ret;
917
918
306974
    av_init_packet(&pkt);
919
306974
    pkt.data = NULL;
920
306974
    pkt.size = 0;
921
922
306974
    if (!check_recording_time(ost))
923
        return;
924
925

306974
    if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
926
        frame->pts = ost->sync_opts;
927
306974
    ost->sync_opts = frame->pts + frame->nb_samples;
928
306974
    ost->samples_encoded += frame->nb_samples;
929
306974
    ost->frames_encoded++;
930
931

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

101427
    if (frame_rate.num > 0 && frame_rate.den > 0)
1076
101393
        duration = 1/(av_q2d(frame_rate) * av_q2d(enc->time_base));
1077
1078


101427
    if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1079
65062
        duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
1080
1081
101427
    if (!ost->filters_script &&
1082
101330
        !ost->filters &&
1083

94826
        (nb_filtergraphs == 0 || !filtergraphs[0]->graph_desc) &&
1084
90528
        next_picture &&
1085
90528
        ist &&
1086
90528
        lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
1087
85801
        duration = lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
1088
    }
1089
1090
101427
    if (!next_picture) {
1091
        //end, flushing
1092
2407
        nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
1093
                                          ost->last_nb0_frames[1],
1094
                                          ost->last_nb0_frames[2]);
1095
    } else {
1096
99020
        delta0 = sync_ipts - ost->sync_opts; // delta0 is the "drift" between the input frame (next_picture) and where it would fall in the output.
1097
99020
        delta  = delta0 + duration;
1098
1099
        /* by default, we output a single frame */
1100
99020
        nb0_frames = 0; // tracks the number of times the PREVIOUS frame should be duplicated, mostly for variable framerate (VFR)
1101
99020
        nb_frames = 1;
1102
1103
99020
        format_video_sync = video_sync_method;
1104
99020
        if (format_video_sync == VSYNC_AUTO) {
1105
56086
            if(!strcmp(of->ctx->oformat->name, "avi")) {
1106
12650
                format_video_sync = VSYNC_VFR;
1107
            } else
1108

43436
                format_video_sync = (of->ctx->oformat->flags & AVFMT_VARIABLE_FPS) ? ((of->ctx->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
1109
56086
            if (   ist
1110
54653
                && format_video_sync == VSYNC_CFR
1111
9424
                && input_files[ist->file_index]->ctx->nb_streams == 1
1112
8349
                && input_files[ist->file_index]->input_ts_offset == 0) {
1113
8349
                format_video_sync = VSYNC_VSCFR;
1114
            }
1115

56086
            if (format_video_sync == VSYNC_CFR && copy_ts) {
1116
                format_video_sync = VSYNC_VSCFR;
1117
            }
1118
        }
1119

99020
        ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
1120
1121

99020
        if (delta0 < 0 &&
1122
11137
            delta > 0 &&
1123
10709
            format_video_sync != VSYNC_PASSTHROUGH &&
1124
            format_video_sync != VSYNC_DROP) {
1125
7940
            if (delta0 < -0.6) {
1126
431
                av_log(NULL, AV_LOG_VERBOSE, "Past duration %f too large\n", -delta0);
1127
            } else
1128
7509
                av_log(NULL, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
1129
7940
            sync_ipts = ost->sync_opts;
1130
7940
            duration += delta0;
1131
7940
            delta0 = 0;
1132
        }
1133
1134

99020
        switch (format_video_sync) {
1135
8349
        case VSYNC_VSCFR:
1136

8349
            if (ost->frame_number == 0 && delta0 >= 0.5) {
1137
                av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
1138
                delta = duration;
1139
                delta0 = 0;
1140
                ost->sync_opts = lrint(sync_ipts);
1141
            }
1142
        case VSYNC_CFR:
1143
            // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1144

9578
            if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
1145
                nb_frames = 0;
1146
9578
            } else if (delta < -1.1)
1147
                nb_frames = 0;
1148
9578
            else if (delta > 1.1) {
1149
350
                nb_frames = lrintf(delta);
1150
350
                if (delta0 > 1.1)
1151
2
                    nb0_frames = lrintf(delta0 - 0.6);
1152
            }
1153
9578
            break;
1154
46645
        case VSYNC_VFR:
1155
46645
            if (delta <= -0.6)
1156
170
                nb_frames = 0;
1157
46475
            else if (delta > 0.6)
1158
45893
                ost->sync_opts = lrint(sync_ipts);
1159
46645
            break;
1160
42797
        case VSYNC_DROP:
1161
        case VSYNC_PASSTHROUGH:
1162
42797
            ost->sync_opts = lrint(sync_ipts);
1163
42797
            break;
1164
        default:
1165
            av_assert0(0);
1166
        }
1167
    }
1168
1169
101427
    nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1170
101427
    nb0_frames = FFMIN(nb0_frames, nb_frames);
1171
1172
101427
    memmove(ost->last_nb0_frames + 1,
1173
101427
            ost->last_nb0_frames,
1174
            sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
1175
101427
    ost->last_nb0_frames[0] = nb0_frames;
1176
1177

101427
    if (nb0_frames == 0 && ost->last_dropped) {
1178
170
        nb_frames_drop++;
1179
170
        av_log(NULL, AV_LOG_VERBOSE,
1180
               "*** dropping frame %d from stream %d at ts %"PRId64"\n",
1181
170
               ost->frame_number, ost->st->index, ost->last_frame->pts);
1182
    }
1183

101427
    if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) {
1184
49
        if (nb_frames > dts_error_threshold * 30) {
1185
            av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
1186
            nb_frames_drop++;
1187
            return;
1188
        }
1189

49
        nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
1190
49
        av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1191
49
        if (nb_frames_dup > dup_warning) {
1192
            av_log(NULL, AV_LOG_WARNING, "More than %d frames duplicated\n", dup_warning);
1193
            dup_warning *= 10;
1194
        }
1195
    }
1196

101427
    ost->last_dropped = nb_frames == nb0_frames && next_picture;
1197
1198
    /* duplicates frame if needed */
1199
200485
    for (i = 0; i < nb_frames; i++) {
1200
        AVFrame *in_picture;
1201
99059
        int forced_keyframe = 0;
1202
        double pts_time;
1203
99059
        av_init_packet(&pkt);
1204
99059
        pkt.data = NULL;
1205
99059
        pkt.size = 0;
1206
1207

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

98858
            if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
1310
                pkt.pts = ost->sync_opts;
1311
1312
98858
            av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1313
1314
98858
            if (debug_ts) {
1315
                av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1316
                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1317
                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->mux_timebase),
1318
                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->mux_timebase));
1319
            }
1320
1321
98858
            frame_size = pkt.size;
1322
98858
            output_packet(of, &pkt, ost, 0);
1323
1324
            /* if two pass, output log */
1325

98858
            if (ost->logfile && enc->stats_out) {
1326
                fprintf(ost->logfile, "%s", enc->stats_out);
1327
            }
1328
        }
1329
99058
        ost->sync_opts++;
1330
        /*
1331
         * For video, number of frames in == number of packets out.
1332
         * But there may be reordering, so we can't throw away frames on encoder
1333
         * flush, we need to limit them here, before they go into encoder.
1334
         */
1335
99058
        ost->frame_number++;
1336
1337

99058
        if (vstats_filename && frame_size)
1338
            do_video_stats(ost, frame_size);
1339
    }
1340
1341
101426
    if (!ost->last_frame)
1342
4673
        ost->last_frame = av_frame_alloc();
1343
101426
    av_frame_unref(ost->last_frame);
1344

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

435658
        if (!ost->filter || !ost->filter->graph->graph)
1438
46137
            continue;
1439
389521
        filter = ost->filter->filter;
1440
1441
389521
        if (!ost->initialized) {
1442
5645
            char error[1024] = "";
1443
5645
            ret = init_output_stream(ost, error, sizeof(error));
1444
5645
            if (ret < 0) {
1445
                av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1446
                       ost->file_index, ost->index, error);
1447
                exit_program(1);
1448
            }
1449
        }
1450
1451

389521
        if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
1452
            return AVERROR(ENOMEM);
1453
        }
1454
389521
        filtered_frame = ost->filtered_frame;
1455
1456
405994
        while (1) {
1457
795515
            double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
1458
795515
            ret = av_buffersink_get_frame_flags(filter, filtered_frame,
1459
                                               AV_BUFFERSINK_FLAG_NO_REQUEST);
1460
795515
            if (ret < 0) {
1461

389521
                if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1462
                    av_log(NULL, AV_LOG_WARNING,
1463
                           "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1464

389521
                } else if (flush && ret == AVERROR_EOF) {
1465
3533
                    if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
1466
2407
                        do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
1467
                }
1468
389521
                break;
1469
            }
1470
405994
            if (ost->finished) {
1471
                av_frame_unref(filtered_frame);
1472
                continue;
1473
            }
1474
405994
            if (filtered_frame->pts != AV_NOPTS_VALUE) {
1475
405994
                int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1476
405994
                AVRational filter_tb = av_buffersink_get_time_base(filter);
1477
405994
                AVRational tb = enc->time_base;
1478
405994
                int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
1479
1480
405994
                tb.den <<= extra_bits;
1481
405994
                float_pts =
1482
405994
                    av_rescale_q(filtered_frame->pts, filter_tb, tb) -
1483
405994
                    av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
1484
405994
                float_pts /= 1 << extra_bits;
1485
                // 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
1486
405994
                float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
1487
1488
405994
                filtered_frame->pts =
1489
405994
                    av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
1490
405994
                    av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
1491
            }
1492
1493
405994
            switch (av_buffersink_get_type(filter)) {
1494
99020
            case AVMEDIA_TYPE_VIDEO:
1495
99020
                if (!ost->frame_aspect_ratio.num)
1496
99020
                    enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
1497
1498
99020
                if (debug_ts) {
1499
                    av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
1500
                            av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
1501
                            float_pts,
1502
                            enc->time_base.num, enc->time_base.den);
1503
                }
1504
1505
99020
                do_video_out(of, ost, filtered_frame, float_pts);
1506
99020
                break;
1507
306974
            case AVMEDIA_TYPE_AUDIO:
1508
306974
                if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
1509
306974
                    enc->channels != filtered_frame->channels) {
1510
                    av_log(NULL, AV_LOG_ERROR,
1511
                           "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1512
                    break;
1513
                }
1514
306974
                do_audio_out(of, ost, filtered_frame);
1515
306974
                break;
1516
            default:
1517
                // TODO support subtitle filters
1518
                av_assert0(0);
1519
            }
1520
1521
405994
            av_frame_unref(filtered_frame);
1522
        }
1523
    }
1524
1525
421043
    return 0;
1526
}
1527
1528
5840
static void print_final_stats(int64_t total_size)
1529
{
1530
5840
    uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
1531
5840
    uint64_t subtitle_size = 0;
1532
5840
    uint64_t data_size = 0;
1533
5840
    float percent = -1.0;
1534
    int i, j;
1535
5840
    int pass1_used = 1;
1536
1537
11822
    for (i = 0; i < nb_output_streams; i++) {
1538
5982
        OutputStream *ost = output_streams[i];
1539

5982
        switch (ost->enc_ctx->codec_type) {
1540
4746
            case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1541
1189
            case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1542
36
            case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1543
11
            default:                 other_size += ost->data_size; break;
1544
        }
1545
5982
        extra_size += ost->enc_ctx->extradata_size;
1546
5982
        data_size  += ost->data_size;
1547
5982
        if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2))
1548
            != AV_CODEC_FLAG_PASS1)
1549
5982
            pass1_used = 0;
1550
    }
1551
1552

5840
    if (data_size && total_size>0 && total_size >= data_size)
1553
4043
        percent = 100.0 * (total_size - data_size) / data_size;
1554
1555
5840
    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: ",
1556
           video_size / 1024.0,
1557
           audio_size / 1024.0,
1558
           subtitle_size / 1024.0,
1559
           other_size / 1024.0,
1560
           extra_size / 1024.0);
1561
5840
    if (percent >= 0.0)
1562
4043
        av_log(NULL, AV_LOG_INFO, "%f%%", percent);
1563
    else
1564
1797
        av_log(NULL, AV_LOG_INFO, "unknown");
1565
5840
    av_log(NULL, AV_LOG_INFO, "\n");
1566
1567
    /* print verbose per-stream stats */
1568
11712
    for (i = 0; i < nb_input_files; i++) {
1569
5872
        InputFile *f = input_files[i];
1570
5872
        uint64_t total_packets = 0, total_size = 0;
1571
1572
5872
        av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
1573
5872
               i, f->ctx->url);
1574
1575
12060
        for (j = 0; j < f->nb_streams; j++) {
1576
6188
            InputStream *ist = input_streams[f->ist_index + j];
1577
6188
            enum AVMediaType type = ist->dec_ctx->codec_type;
1578
1579
6188
            total_size    += ist->data_size;
1580
6188
            total_packets += ist->nb_packets;
1581
1582
6188
            av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
1583
                   i, j, media_type_string(type));
1584
6188
            av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
1585
                   ist->nb_packets, ist->data_size);
1586
1587
6188
            if (ist->decoding_needed) {
1588
5691
                av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
1589
                       ist->frames_decoded);
1590
5691
                if (type == AVMEDIA_TYPE_AUDIO)
1591
1094
                    av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
1592
5691
                av_log(NULL, AV_LOG_VERBOSE, "; ");
1593
            }
1594
1595
6188
            av_log(NULL, AV_LOG_VERBOSE, "\n");
1596
        }
1597
1598
5872
        av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
1599
               total_packets, total_size);
1600
    }
1601
1602
11681
    for (i = 0; i < nb_output_files; i++) {
1603
5841
        OutputFile *of = output_files[i];
1604
5841
        uint64_t total_packets = 0, total_size = 0;
1605
1606
5841
        av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
1607
5841
               i, of->ctx->url);
1608
1609
11823
        for (j = 0; j < of->ctx->nb_streams; j++) {
1610
5982
            OutputStream *ost = output_streams[of->ost_index + j];
1611
5982
            enum AVMediaType type = ost->enc_ctx->codec_type;
1612
1613
5982
            total_size    += ost->data_size;
1614
5982
            total_packets += ost->packets_written;
1615
1616
5982
            av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
1617
                   i, j, media_type_string(type));
1618
5982
            if (ost->encoding_needed) {
1619
5712
                av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
1620
                       ost->frames_encoded);
1621
5712
                if (type == AVMEDIA_TYPE_AUDIO)
1622
1092
                    av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
1623
5712
                av_log(NULL, AV_LOG_VERBOSE, "; ");
1624
            }
1625
1626
5982
            av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
1627
                   ost->packets_written, ost->data_size);
1628
1629
5982
            av_log(NULL, AV_LOG_VERBOSE, "\n");
1630
        }
1631
1632
5841
        av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
1633
               total_packets, total_size);
1634
    }
1635
5840
    if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
1636
5
        av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
1637
5
        if (pass1_used) {
1638
1
            av_log(NULL, AV_LOG_WARNING, "\n");
1639
        } else {
1640
4
            av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
1641
        }
1642
    }
1643
5840
}
1644
1645
1150051
static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1646
{
1647
    AVBPrint buf, buf_script;
1648
    OutputStream *ost;
1649
    AVFormatContext *oc;
1650
    int64_t total_size;
1651
    AVCodecContext *enc;
1652
    int frame_number, vid, i;
1653
    double bitrate;
1654
    double speed;
1655
1150051
    int64_t pts = INT64_MIN + 1;
1656
    static int64_t last_time = -1;
1657
    static int qp_histogram[52];
1658
    int hours, mins, secs, us;
1659
    const char *hours_sign;
1660
    int ret;
1661
    float t;
1662
1663

1150051
    if (!print_stats && !is_last_report && !progress_avio)
1664
1144185
        return;
1665
1666
15898
    if (!is_last_report) {
1667
10058
        if (last_time == -1) {
1668
31
            last_time = cur_time;
1669
31
            return;
1670
        }
1671
10027
        if ((cur_time - last_time) < 500000)
1672
10001
            return;
1673
26
        last_time = cur_time;
1674
    }
1675
1676
5866
    t = (cur_time-timer_start) / 1000000.0;
1677
1678
1679
5866
    oc = output_files[0]->ctx;
1680
1681
5866
    total_size = avio_size(oc->pb);
1682
5866
    if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1683
77
        total_size = avio_tell(oc->pb);
1684
1685
5866
    vid = 0;
1686
5866
    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1687
5866
    av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
1688
11874
    for (i = 0; i < nb_output_streams; i++) {
1689
6008
        float q = -1;
1690
6008
        ost = output_streams[i];
1691
6008
        enc = ost->enc_ctx;
1692
6008
        if (!ost->stream_copy)
1693
5739
            q = ost->quality / (float) FF_QP2LAMBDA;
1694
1695

6008
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1696
7
            av_bprintf(&buf, "q=%2.1f ", q);
1697
7
            av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1698
                       ost->file_index, ost->index, q);
1699
        }
1700

6008
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1701
            float fps;
1702
1703
4741
            frame_number = ost->frame_number;
1704
4741
            fps = t > 1 ? frame_number / t : 0;
1705
4741
            av_bprintf(&buf, "frame=%5d fps=%3.*f q=%3.1f ",
1706
                     frame_number, fps < 9.95, fps, q);
1707
4741
            av_bprintf(&buf_script, "frame=%d\n", frame_number);
1708
4741
            av_bprintf(&buf_script, "fps=%.2f\n", fps);
1709
4741
            av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1710
                       ost->file_index, ost->index, q);
1711
4741
            if (is_last_report)
1712
4739
                av_bprintf(&buf, "L");
1713
4741
            if (qp_hist) {
1714
                int j;
1715
                int qp = lrintf(q);
1716
                if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1717
                    qp_histogram[qp]++;
1718
                for (j = 0; j < 32; j++)
1719
                    av_bprintf(&buf, "%X", av_log2(qp_histogram[j] + 1));
1720
            }
1721
1722

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

5866
    bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1770
5866
    speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
1771
1772
5866
    if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
1773
5789
    else                av_bprintf(&buf, "size=%8.0fkB time=", total_size / 1024.0);
1774
5866
    if (pts == AV_NOPTS_VALUE) {
1775
        av_bprintf(&buf, "N/A ");
1776
    } else {
1777
5866
        av_bprintf(&buf, "%s%02d:%02d:%02d.%02d ",
1778
                   hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
1779
    }
1780
1781
5866
    if (bitrate < 0) {
1782
88
        av_bprintf(&buf, "bitrate=N/A");
1783
88
        av_bprintf(&buf_script, "bitrate=N/A\n");
1784
    }else{
1785
5778
        av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
1786
5778
        av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1787
    }
1788
1789
5866
    if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1790
5789
    else                av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1791
5866
    if (pts == AV_NOPTS_VALUE) {
1792
        av_bprintf(&buf_script, "out_time_us=N/A\n");
1793
        av_bprintf(&buf_script, "out_time_ms=N/A\n");
1794
        av_bprintf(&buf_script, "out_time=N/A\n");
1795
    } else {
1796
5866
        av_bprintf(&buf_script, "out_time_us=%"PRId64"\n", pts);
1797
5866
        av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1798
5866
        av_bprintf(&buf_script, "out_time=%s%02d:%02d:%02d.%06d\n",
1799
                   hours_sign, hours, mins, secs, us);
1800
    }
1801
1802

5866
    if (nb_frames_dup || nb_frames_drop)
1803
26
        av_bprintf(&buf, " dup=%d drop=%d", nb_frames_dup, nb_frames_drop);
1804
5866
    av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1805
5866
    av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1806
1807
5866
    if (speed < 0) {
1808
1
        av_bprintf(&buf, " speed=N/A");
1809
1
        av_bprintf(&buf_script, "speed=N/A\n");
1810
    } else {
1811
5865
        av_bprintf(&buf, " speed=%4.3gx", speed);
1812
5865
        av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
1813
    }
1814
1815

5866
    if (print_stats || is_last_report) {
1816
5866
        const char end = is_last_report ? '\n' : '\r';
1817

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

5712
        if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1908
999
            continue;
1909
1910

4713
        if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
1911
30
            continue;
1912
1913
239
        for (;;) {
1914
4922
            const char *desc = NULL;
1915
            AVPacket pkt;
1916
            int pkt_size;
1917
1918
4922
            switch (enc->codec_type) {
1919
132
            case AVMEDIA_TYPE_AUDIO:
1920
132
                desc   = "audio";
1921
132
                break;
1922
4790
            case AVMEDIA_TYPE_VIDEO:
1923
4790
                desc   = "video";
1924
4790
                break;
1925
            default:
1926
                av_assert0(0);
1927
            }
1928
1929
4922
            av_init_packet(&pkt);
1930
4922
            pkt.data = NULL;
1931
4922
            pkt.size = 0;
1932
1933
4922
            update_benchmark(NULL);
1934
1935
9605
            while ((ret = avcodec_receive_packet(enc, &pkt)) == AVERROR(EAGAIN)) {
1936
4683
                ret = avcodec_send_frame(enc, NULL);
1937
4683
                if (ret < 0) {
1938
                    av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1939
                           desc,
1940
                           av_err2str(ret));
1941
                    exit_program(1);
1942
                }
1943
            }
1944
1945
4922
            update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
1946

4922
            if (ret < 0 && ret != AVERROR_EOF) {
1947
                av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1948
                       desc,
1949
                       av_err2str(ret));
1950
                exit_program(1);
1951
            }
1952

4922
            if (ost->logfile && enc->stats_out) {
1953
                fprintf(ost->logfile, "%s", enc->stats_out);
1954
            }
1955
4922
            if (ret == AVERROR_EOF) {
1956
4683
                output_packet(of, &pkt, ost, 1);
1957
4683
                break;
1958
            }
1959
239
            if (ost->finished & MUXER_FINISHED) {
1960
                av_packet_unref(&pkt);
1961
                continue;
1962
            }
1963
239
            av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1964
239
            pkt_size = pkt.size;
1965
239
            output_packet(of, &pkt, ost, 0);
1966

239
            if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1967
                do_video_stats(ost, pkt_size);
1968
            }
1969
        }
1970
    }
1971
5840
}
1972
1973
/*
1974
 * Check whether a packet from ist should be written into ost at this time
1975
 */
1976
423245
static int check_output_constraints(InputStream *ist, OutputStream *ost)
1977
{
1978
423245
    OutputFile *of = output_files[ost->file_index];
1979
423245
    int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1980
1981
423245
    if (ost->source_index != ist_index)
1982
16967
        return 0;
1983
1984
406278
    if (ost->finished)
1985
2814
        return 0;
1986
1987

403464
    if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1988
        return 0;
1989
1990
403464
    return 1;
1991
}
1992
1993
29630
static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1994
{
1995
29630
    OutputFile *of = output_files[ost->file_index];
1996
29630
    InputFile   *f = input_files [ist->file_index];
1997
29630
    int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1998
29630
    int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
1999
    AVPacket opkt;
2000
2001
    // EOF: flush output bitstream filters.
2002
29630
    if (!pkt) {
2003
        av_init_packet(&opkt);
2004
        opkt.data = NULL;
2005
        opkt.size = 0;
2006
        output_packet(of, &opkt, ost, 1);
2007
18
        return;
2008
    }
2009
2010

29630
    if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2011
11
        !ost->copy_initial_nonkeyframes)
2012
11
        return;
2013
2014

29619
    if (!ost->frame_number && !ost->copy_prior_start) {
2015
        int64_t comp_start = start_time;
2016
        if (copy_ts && f->start_time != AV_NOPTS_VALUE)
2017
            comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
2018
        if (pkt->pts == AV_NOPTS_VALUE ?
2019
            ist->pts < comp_start :
2020
            pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
2021
            return;
2022
    }
2023
2024
29619
    if (of->recording_time != INT64_MAX &&
2025
416
        ist->pts >= of->recording_time + start_time) {
2026
5
        close_output_stream(ost);
2027
5
        return;
2028
    }
2029
2030
29614
    if (f->recording_time != INT64_MAX) {
2031
148
        start_time = f->ctx->start_time;
2032

148
        if (f->start_time != AV_NOPTS_VALUE && copy_ts)
2033
74
            start_time += f->start_time;
2034
148
        if (ist->pts >= f->recording_time + start_time) {
2035
2
            close_output_stream(ost);
2036
2
            return;
2037
        }
2038
    }
2039
2040
    /* force the input stream PTS */
2041
29612
    if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2042
8923
        ost->sync_opts++;
2043
2044
29612
    if (av_packet_ref(&opkt, pkt) < 0)
2045
        exit_program(1);
2046
2047
29612
    if (pkt->pts != AV_NOPTS_VALUE)
2048
24608
        opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
2049
2050
29612
    if (pkt->dts == AV_NOPTS_VALUE)
2051
4752
        opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->mux_timebase);
2052
    else
2053
24860
        opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
2054
29612
    opkt.dts -= ost_tb_start_time;
2055
2056

29612
    if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
2057
20159
        int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
2058
20159
        if(!duration)
2059
7408
            duration = ist->dec_ctx->frame_size;
2060
40318
        opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
2061
20159
                                               (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
2062
20159
                                               ost->mux_timebase) - ost_tb_start_time;
2063
    }
2064
2065
29612
    opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
2066
2067
29612
    output_packet(of, &opkt, ost, 0);
2068
}
2069
2070
1329
int guess_input_channel_layout(InputStream *ist)
2071
{
2072
1329
    AVCodecContext *dec = ist->dec_ctx;
2073
2074
1329
    if (!dec->channel_layout) {
2075
        char layout_name[256];
2076
2077
741
        if (dec->channels > ist->guess_layout_max)
2078
6
            return 0;
2079
737
        dec->channel_layout = av_get_default_channel_layout(dec->channels);
2080
737
        if (!dec->channel_layout)
2081
2
            return 0;
2082
735
        av_get_channel_layout_string(layout_name, sizeof(layout_name),
2083
                                     dec->channels, dec->channel_layout);
2084
735
        av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2085
735
               "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2086
    }
2087
1323
    return 1;
2088
}
2089
2090
763687
static void check_decode_result(InputStream *ist, int *got_output, int ret)
2091
{
2092

763687
    if (*got_output || ret<0)
2093
393623
        decode_error_stat[ret<0] ++;
2094
2095

763687
    if (ret < 0 && exit_on_error)
2096
        exit_program(1);
2097
2098

763687
    if (*got_output && ist) {
2099

392564
        if (ist->decoded_frame->decode_error_flags || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
2100
36
            av_log(NULL, exit_on_error ? AV_LOG_FATAL : AV_LOG_WARNING,
2101
36
                   "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->url, ist->st->index);
2102
36
            if (exit_on_error)
2103
                exit_program(1);
2104
        }
2105
    }
2106
763687
}
2107
2108
// Filters can be configured only if the formats of all inputs are known.
2109
739219
static int ifilter_has_all_input_formats(FilterGraph *fg)
2110
{
2111
    int i;
2112
760379
    for (i = 0; i < fg->nb_inputs; i++) {
2113

754642
        if (fg->inputs[i]->format < 0 && (fg->inputs[i]->type == AVMEDIA_TYPE_AUDIO ||
2114
733461
                                          fg->inputs[i]->type == AVMEDIA_TYPE_VIDEO))
2115
733482
            return 0;
2116
    }
2117
5737
    return 1;
2118
}
2119
2120
392952
static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
2121
{
2122
392952
    FilterGraph *fg = ifilter->graph;
2123
    int need_reinit, ret, i;
2124
2125
    /* determine if the parameters for this input changed */
2126
392952
    need_reinit = ifilter->format != frame->format;
2127
2128
392952
    switch (ifilter->ist->st->codecpar->codec_type) {
2129
294090
    case AVMEDIA_TYPE_AUDIO:
2130
881175
        need_reinit |= ifilter->sample_rate    != frame->sample_rate ||
2131

587084
                       ifilter->channels       != frame->channels ||
2132
292994
                       ifilter->channel_layout != frame->channel_layout;
2133
294090
        break;
2134
98862
    case AVMEDIA_TYPE_VIDEO:
2135
193135
        need_reinit |= ifilter->width  != frame->width ||
2136
94273
                       ifilter->height != frame->height;
2137
98862
        break;
2138
    }
2139
2140

392952
    if (!ifilter->ist->reinit_filters && fg->graph)
2141
        need_reinit = 0;
2142
2143
392952
    if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
2144

392952
        (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
2145
        need_reinit = 1;
2146
2147
392952
    if (need_reinit) {
2148
5698
        ret = ifilter_parameters_from_frame(ifilter, frame);
2149
5698
        if (ret < 0)
2150
            return ret;
2151
    }
2152
2153
    /* (re)init the graph if possible, otherwise buffer the frame and return */
2154

392952
    if (need_reinit || !fg->graph) {
2155
11398
        for (i = 0; i < fg->nb_inputs; i++) {
2156
5719
            if (!ifilter_has_all_input_formats(fg)) {
2157
19
                AVFrame *tmp = av_frame_clone(frame);
2158
19
                if (!tmp)
2159
                    return AVERROR(ENOMEM);
2160
19
                av_frame_unref(frame);
2161
2162
19
                if (!av_fifo_space(ifilter->frame_queue)) {
2163
                    ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
2164
                    if (ret < 0) {
2165
                        av_frame_free(&tmp);
2166
                        return ret;
2167
                    }
2168
                }
2169
19
                av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
2170
19
                return 0;
2171
            }
2172
        }
2173
2174
5679
        ret = reap_filters(1);
2175

5679
        if (ret < 0 && ret != AVERROR_EOF) {
2176
            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2177
            return ret;
2178
        }
2179
2180
5679
        ret = configure_filtergraph(fg);
2181
5679
        if (ret < 0) {
2182
            av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
2183
            return ret;
2184
        }
2185
    }
2186
2187
392933
    ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, AV_BUFFERSRC_FLAG_PUSH);
2188
392933
    if (ret < 0) {
2189
        if (ret != AVERROR_EOF)
2190
            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2191
        return ret;
2192
    }
2193
2194
392933
    return 0;
2195
}
2196
2197
5651
static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
2198
{
2199
    int ret;
2200
2201
5651
    ifilter->eof = 1;
2202
2203
5651
    if (ifilter->filter) {
2204
5651
        ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH);
2205
5651
        if (ret < 0)
2206
            return ret;
2207
    } else {
2208
        // the filtergraph was never configured
2209
        if (ifilter->format < 0)
2210
            ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
2211
        if (ifilter->format < 0 && (ifilter->type == AVMEDIA_TYPE_AUDIO || ifilter->type == AVMEDIA_TYPE_VIDEO)) {
2212
            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);
2213
            return AVERROR_INVALIDDATA;
2214
        }
2215
    }
2216
2217
5651
    return 0;
2218
}
2219
2220
// This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
2221
// There is the following difference: if you got a frame, you must call
2222
// it again with pkt=NULL. pkt==NULL is treated differently from pkt->size==0
2223
// (pkt==NULL means get more output, pkt->size==0 is a flush/drain packet)
2224
768168
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
2225
{
2226
    int ret;
2227
2228
768168
    *got_frame = 0;
2229
2230
768168
    if (pkt) {
2231
376277
        ret = avcodec_send_packet(avctx, pkt);
2232
        // In particular, we don't expect AVERROR(EAGAIN), because we read all
2233
        // decoded frames with avcodec_receive_frame() until done.
2234

376277
        if (ret < 0 && ret != AVERROR_EOF)
2235
379
            return ret;
2236
    }
2237
2238
767789
    ret = avcodec_receive_frame(avctx, frame);
2239

767789
    if (ret < 0 && ret != AVERROR(EAGAIN))
2240
5653
        return ret;
2241
762136
    if (ret >= 0)
2242
392564
        *got_frame = 1;
2243
2244
762136
    return 0;
2245
}
2246
2247
392564
static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
2248
{
2249
    int i, ret;
2250
    AVFrame *f;
2251
2252
    av_assert1(ist->nb_filters > 0); /* ensure ret is initialized */
2253
785516
    for (i = 0; i < ist->nb_filters; i++) {
2254
392952
        if (i < ist->nb_filters - 1) {
2255
388
            f = ist->filter_frame;
2256
388
            ret = av_frame_ref(f, decoded_frame);
2257
388
            if (ret < 0)
2258
                break;
2259
        } else
2260
392564
            f = decoded_frame;
2261
392952
        ret = ifilter_send_frame(ist->filters[i], f);
2262
392952
        if (ret == AVERROR_EOF)
2263
            ret = 0; /* ignore */
2264
392952
        if (ret < 0) {
2265
            av_log(NULL, AV_LOG_ERROR,
2266
                   "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2267
            break;
2268
        }
2269
    }
2270
392564
    return ret;
2271
}
2272
2273
561723
static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
2274
                        int *decode_failed)
2275
{
2276
    AVFrame *decoded_frame;
2277
561723
    AVCodecContext *avctx = ist->dec_ctx;
2278
561723
    int ret, err = 0;
2279
    AVRational decoded_frame_tb;
2280
2281

561723
    if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2282
        return AVERROR(ENOMEM);
2283

561723
    if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2284
        return AVERROR(ENOMEM);
2285
561723
    decoded_frame = ist->decoded_frame;
2286
2287
561723
    update_benchmark(NULL);
2288
561723
    ret = decode(avctx, decoded_frame, got_output, pkt);
2289
561723
    update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2290
561723
    if (ret < 0)
2291
1103
        *decode_failed = 1;
2292
2293

561723
    if (ret >= 0 && avctx->sample_rate <= 0) {
2294
        av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2295
        ret = AVERROR_INVALIDDATA;
2296
    }
2297
2298
561723
    if (ret != AVERROR_EOF)
2299
560630
        check_decode_result(ist, got_output, ret);
2300
2301

561723
    if (!*got_output || ret < 0)
2302
268021
        return ret;
2303
2304
293702
    ist->samples_decoded += decoded_frame->nb_samples;
2305
293702
    ist->frames_decoded++;
2306
2307
    /* increment next_dts to use for the case where the input stream does not
2308
       have timestamps or there are multiple frames in the packet */
2309
293702
    ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2310
293702
                     avctx->sample_rate;
2311
293702
    ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2312
293702
                     avctx->sample_rate;
2313
2314
293702
    if (decoded_frame->pts != AV_NOPTS_VALUE) {
2315
265542
        decoded_frame_tb   = ist->st->time_base;
2316

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

207990
    if (!eof && pkt && pkt->size == 0)
2348
1545
        return 0;
2349
2350

206445
    if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2351
        return AVERROR(ENOMEM);
2352

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

206445
    if (*got_output && ret >= 0) {
2397
98862
        if (ist->dec_ctx->width  != decoded_frame->width ||
2398
98853
            ist->dec_ctx->height != decoded_frame->height ||
2399
98851
            ist->dec_ctx->pix_fmt != decoded_frame->format) {
2400
15
            av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2401
                decoded_frame->width,
2402
                decoded_frame->height,
2403
                decoded_frame->format,
2404
15
                ist->dec_ctx->width,
2405
15
                ist->dec_ctx->height,
2406
15
                ist->dec_ctx->pix_fmt);
2407
        }
2408
    }
2409
2410

206445
    if (!*got_output || ret < 0)
2411
107583
        return ret;
2412
2413
98862
    if(ist->top_field_first>=0)
2414
        decoded_frame->top_field_first = ist->top_field_first;
2415
2416
98862
    ist->frames_decoded++;
2417
2418

98862
    if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2419
        err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2420
        if (err < 0)
2421
            goto fail;
2422
    }
2423
98862
    ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2424
2425
98862
    best_effort_timestamp= decoded_frame->best_effort_timestamp;
2426
98862
    *duration_pts = decoded_frame->pkt_duration;
2427
2428
98862
    if (ist->framerate.num)
2429
103
        best_effort_timestamp = ist->cfr_next_pts++;
2430
2431

98862
    if (eof && best_effort_timestamp == AV_NOPTS_VALUE && ist->nb_dts_buffer > 0) {
2432
524
        best_effort_timestamp = ist->dts_buffer[0];
2433
2434
524
        for (i = 0; i < ist->nb_dts_buffer - 1; i++)
2435
            ist->dts_buffer[i] = ist->dts_buffer[i + 1];
2436
524
        ist->nb_dts_buffer--;
2437
    }
2438
2439
98862
    if(best_effort_timestamp != AV_NOPTS_VALUE) {
2440
98862
        int64_t ts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2441
2442
98862
        if (ts != AV_NOPTS_VALUE)
2443
98862
            ist->next_pts = ist->pts = ts;
2444
    }
2445
2446
98862
    if (debug_ts) {
2447
        av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2448
               "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",
2449
               ist->st->index, av_ts2str(decoded_frame->pts),
2450
               av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2451
               best_effort_timestamp,
2452
               av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2453
               decoded_frame->key_frame, decoded_frame->pict_type,
2454
               ist->st->time_base.num, ist->st->time_base.den);
2455
    }
2456
2457
98862
    if (ist->st->sample_aspect_ratio.num)
2458
4799
        decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2459
2460
98862
    err = send_frame_to_filters(ist, decoded_frame);
2461
2462
98862
fail:
2463
98862
    av_frame_unref(ist->filter_frame);
2464
98862
    av_frame_unref(decoded_frame);
2465
98862
    return err < 0 ? err : ret;
2466
}
2467
2468
1167
static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
2469
                               int *decode_failed)
2470
{
2471
    AVSubtitle subtitle;
2472
1167
    int free_sub = 1;
2473
1167
    int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2474
                                          &subtitle, got_output, pkt);
2475
2476
1167
    check_decode_result(NULL, got_output, ret);
2477
2478

1167
    if (ret < 0 || !*got_output) {
2479
571
        *decode_failed = 1;
2480
571
        if (!pkt->size)
2481
31
            sub2video_flush(ist);
2482
571
        return ret;
2483
    }
2484
2485
596
    if (ist->fix_sub_duration) {
2486
        int end = 1;
2487
        if (ist->prev_sub.got_output) {
2488
            end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2489
                             1000, AV_TIME_BASE);
2490
            if (end < ist->prev_sub.subtitle.end_display_time) {
2491
                av_log(ist->dec_ctx, AV_LOG_DEBUG,
2492
                       "Subtitle duration reduced from %"PRId32" to %d%s\n",
2493
                       ist->prev_sub.subtitle.end_display_time, end,
2494
                       end <= 0 ? ", dropping it" : "");
2495
                ist->prev_sub.subtitle.end_display_time = end;
2496
            }
2497
        }
2498
        FFSWAP(int,        *got_output, ist->prev_sub.got_output);
2499
        FFSWAP(int,        ret,         ist->prev_sub.ret);
2500
        FFSWAP(AVSubtitle, subtitle,    ist->prev_sub.subtitle);
2501
        if (end <= 0)
2502
            goto out;
2503
    }
2504
2505
596
    if (!*got_output)
2506
        return ret;
2507
2508
596
    if (ist->sub2video.frame) {
2509
44
        sub2video_update(ist, &subtitle);
2510
552
    } else if (ist->nb_filters) {
2511
        if (!ist->sub2video.sub_queue)
2512
            ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
2513
        if (!ist->sub2video.sub_queue)
2514
            exit_program(1);
2515
        if (!av_fifo_space(ist->sub2video.sub_queue)) {
2516
            ret = av_fifo_realloc2(ist->sub2video.sub_queue, 2 * av_fifo_size(ist->sub2video.sub_queue));
2517
            if (ret < 0)
2518
                exit_program(1);
2519
        }
2520
        av_fifo_generic_write(ist->sub2video.sub_queue, &subtitle, sizeof(subtitle), NULL);
2521
        free_sub = 0;
2522
    }
2523
2524
596
    if (!subtitle.num_rects)
2525
        goto out;
2526
2527
596
    ist->frames_decoded++;
2528
2529
1236
    for (i = 0; i < nb_output_streams; i++) {
2530
640
        OutputStream *ost = output_streams[i];
2531
2532

640
        if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2533
595
            || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2534
45
            continue;
2535
2536
595
        do_subtitle_out(output_files[ost->file_index], ost, &subtitle);
2537
    }
2538
2539
596
out:
2540
596
    if (free_sub)
2541
596
        avsubtitle_free(&subtitle);
2542
596
    return ret;
2543
}
2544
2545
5679
static int send_filter_eof(InputStream *ist)
2546
{
2547
    int i, ret;
2548
    /* TODO keep pts also in stream time base to avoid converting back */
2549
5679
    int64_t pts = av_rescale_q_rnd(ist->pts, AV_TIME_BASE_Q, ist->st->time_base,
2550
                                   AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
2551
2552
11330
    for (i = 0; i < ist->nb_filters; i++) {
2553
5651
        ret = ifilter_send_eof(ist->filters[i], pts);
2554
5651
        if (ret < 0)
2555
            return ret;
2556
    }
2557
5679
    return 0;
2558
}
2559
2560
/* pkt = NULL means EOF (needed to flush decoder buffers) */
2561
408706
static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
2562
{
2563
408706
    int ret = 0, i;
2564
408706
    int repeating = 0;
2565
408706
    int eof_reached = 0;
2566
2567
    AVPacket avpkt;
2568
408706
    if (!ist->saw_first_ts) {
2569
5990
        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;
2570
5990
        ist->pts = 0;
2571

5990
        if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2572
191
            ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2573
191
            ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2574
        }
2575
5990
        ist->saw_first_ts = 1;
2576
    }
2577
2578
408706
    if (ist->next_dts == AV_NOPTS_VALUE)
2579
6404
        ist->next_dts = ist->dts;
2580
408706
    if (ist->next_pts == AV_NOPTS_VALUE)
2581
5990
        ist->next_pts = ist->pts;
2582
2583
408706
    if (!pkt) {
2584
        /* EOF handling */
2585
6417
        av_init_packet(&avpkt);
2586
6417
        avpkt.data = NULL;
2587
6417
        avpkt.size = 0;
2588
    } else {
2589
402289
        avpkt = *pkt;
2590
    }
2591
2592

408706
    if (pkt && pkt->dts != AV_NOPTS_VALUE) {
2593
366024
        ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2594

366024
        if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2595
291628
            ist->next_pts = ist->pts = ist->dts;
2596
    }
2597
2598
    // while we have more to decode or while the decoder did output something on EOF
2599
801193
    while (ist->decoding_needed) {
2600
771476
        int64_t duration_dts = 0;
2601
771476
        int64_t duration_pts = 0;
2602
771476
        int got_output = 0;
2603
771476
        int decode_failed = 0;
2604
2605
771476
        ist->pts = ist->next_pts;
2606
771476
        ist->dts = ist->next_dts;
2607
2608

771476
        switch (ist->dec_ctx->codec_type) {
2609
561723
        case AVMEDIA_TYPE_AUDIO:
2610
561723
            ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
2611
                                   &decode_failed);
2612
561723
            break;
2613
207990
        case AVMEDIA_TYPE_VIDEO:
2614
207990
            ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, &duration_pts, !pkt,
2615
                                   &decode_failed);
2616

207990
            if (!repeating || !pkt || got_output) {
2617

109773
                if (pkt && pkt->duration) {
2618
102283
                    duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2619

7490
                } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2620
6254
                    int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
2621
6254
                    duration_dts = ((int64_t)AV_TIME_BASE *
2622
6254
                                    ist->dec_ctx->framerate.den * ticks) /
2623
6254
                                    ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2624
                }
2625
2626

109773
                if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
2627
108537
                    ist->next_dts += duration_dts;
2628
                }else
2629
1236
                    ist->next_dts = AV_NOPTS_VALUE;
2630
            }
2631
2632
207990
            if (got_output) {
2633
98862
                if (duration_pts > 0) {
2634
96574
                    ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
2635
                } else {
2636
2288
                    ist->next_pts += duration_dts;
2637
                }
2638
            }
2639
207990
            break;
2640
1763
        case AVMEDIA_TYPE_SUBTITLE:
2641
1763
            if (repeating)
2642
596
                break;
2643
1167
            ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
2644

1167
            if (!pkt && ret >= 0)
2645
31
                ret = AVERROR_EOF;
2646
1167
            break;
2647
        default:
2648
            return -1;
2649
        }
2650
2651
771476
        if (ret == AVERROR_EOF) {
2652
5679
            eof_reached = 1;
2653
378989
            break;
2654
        }
2655
2656
765797
        if (ret < 0) {
2657
463
            if (decode_failed) {
2658
926
                av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2659
463
                       ist->file_index, ist->st->index, av_err2str(ret));
2660
            } else {
2661
                av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
2662
                       "data for stream #%d:%d\n", ist->file_index, ist->st->index);
2663
            }
2664

463
            if (!decode_failed || exit_on_error)
2665
                exit_program(1);
2666
463
            break;
2667
        }
2668
2669
765334
        if (got_output)
2670
393160
            ist->got_output = 1;
2671
2672
765334
        if (!got_output)
2673
372174
            break;
2674
2675
        // During draining, we might get multiple output frames in this loop.
2676
        // ffmpeg.c does not drain the filter chain on configuration changes,
2677
        // which means if we send multiple frames at once to the filters, and
2678
        // one of those frames changes configuration, the buffered frames will
2679
        // be lost. This can upset certain FATE tests.
2680
        // Decode only 1 frame per call on EOF to appease these FATE tests.
2681
        // The ideal solution would be to rewrite decoding to use the new
2682
        // decoding API in a better way.
2683
393160
        if (!pkt)
2684
673
            break;
2685
2686
392487
        repeating = 1;
2687
    }
2688
2689
    /* after flushing, send an EOF on all the filter inputs attached to the stream */
2690
    /* except when looping we need to flush but not to send an EOF */
2691


408706
    if (!pkt && ist->decoding_needed && eof_reached && !no_eof) {
2692
5679
        int ret = send_filter_eof(ist);
2693
5679
        if (ret < 0) {
2694
            av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2695
            exit_program(1);
2696
        }
2697
    }
2698
2699
    /* handle stream copy */
2700

408706
    if (!ist->decoding_needed && pkt) {
2701
29653
        ist->dts = ist->next_dts;
2702
29653
        switch (ist->dec_ctx->codec_type) {
2703
20187
        case AVMEDIA_TYPE_AUDIO:
2704
            av_assert1(pkt->duration >= 0);
2705
20187
            if (ist->dec_ctx->sample_rate) {
2706
20187
                ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2707
20187
                                  ist->dec_ctx->sample_rate;
2708
            } else {
2709
                ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2710
            }
2711
20187
            break;
2712
8936
        case AVMEDIA_TYPE_VIDEO:
2713
8936
            if (ist->framerate.num) {
2714
                // TODO: Remove work-around for c99-to-c89 issue 7
2715
79
                AVRational time_base_q = AV_TIME_BASE_Q;
2716
79
                int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2717
79
                ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2718
8857
            } else if (pkt->duration) {
2719
8458
                ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2720
399
            } else if(ist->dec_ctx->framerate.num != 0) {
2721
276
                int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2722
276
                ist->next_dts += ((int64_t)AV_TIME_BASE *
2723
276
                                  ist->dec_ctx->framerate.den * ticks) /
2724
276
                                  ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2725
            }
2726
8936
            break;
2727
        }
2728
29653
        ist->pts = ist->dts;
2729
29653
        ist->next_pts = ist->next_dts;
2730
    }
2731
831311
    for (i = 0; i < nb_output_streams; i++) {
2732
422605
        OutputStream *ost = output_streams[i];
2733
2734

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

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

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

269
    av_assert0(ist && !ost->filter);
3055
3056
269
    ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
3057
269
    if (ret >= 0)
3058
269
        ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
3059
269
    if (ret < 0) {
3060
        av_log(NULL, AV_LOG_FATAL,
3061
               "Error setting up codec context options.\n");
3062
        return ret;
3063
    }
3064
3065
269
    ret = avcodec_parameters_from_context(par_src, ost->enc_ctx);
3066
269
    if (ret < 0) {
3067
        av_log(NULL, AV_LOG_FATAL,
3068
               "Error getting reference codec parameters.\n");
3069
        return ret;
3070
    }
3071
3072
269
    if (!codec_tag) {
3073
        unsigned int codec_tag_tmp;
3074
263
        if (!of->ctx->oformat->codec_tag ||
3075

78
            av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
3076
25
            !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag_tmp))
3077
241
            codec_tag = par_src->codec_tag;
3078
    }
3079
3080
269
    ret = avcodec_parameters_copy(par_dst, par_src);
3081
269
    if (ret < 0)
3082
        return ret;
3083
3084
269
    par_dst->codec_tag = codec_tag;
3085
3086
269
    if (!ost->frame_rate.num)
3087
268
        ost->frame_rate = ist->framerate;
3088
269
    ost->st->avg_frame_rate = ost->frame_rate;
3089
3090
269
    ret = avformat_transfer_internal_stream_timing_info(of->ctx->oformat, ost->st, ist->st, copy_tb);
3091
269
    if (ret < 0)
3092
        return ret;
3093
3094
    // copy timebase while removing common factors
3095

269
    if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3096
268
        ost->st->time_base = av_add_q(av_stream_get_codec_timebase(ost->st), (AVRational){0, 1});
3097
3098
    // copy estimated duration as a hint to the muxer
3099

269
    if (ost->st->duration <= 0 && ist->st->duration > 0)
3100
162
        ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3101
3102
    // copy disposition
3103
269
    ost->st->disposition = ist->st->disposition;
3104
3105
269
    if (ist->st->nb_side_data) {
3106
22
        for (i = 0; i < ist->st->nb_side_data; i++) {
3107
11
            const AVPacketSideData *sd_src = &ist->st->side_data[i];
3108
            uint8_t *dst_data;
3109
3110
11
            dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3111
11
            if (!dst_data)
3112
                return AVERROR(ENOMEM);
3113
11
            memcpy(dst_data, sd_src->data, sd_src->size);
3114
        }
3115
    }
3116
3117
269
    if (ost->rotate_overridden) {
3118
1
        uint8_t *sd = av_stream_new_side_data(ost->st, AV_PKT_DATA_DISPLAYMATRIX,
3119
                                              sizeof(int32_t) * 9);
3120
1
        if (sd)
3121
1
            av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
3122
    }
3123
3124
269
    switch (par_dst->codec_type) {
3125
97
    case AVMEDIA_TYPE_AUDIO:
3126
97
        if (audio_volume != 256) {
3127
            av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3128
            exit_program(1);
3129
        }
3130


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

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

65
            if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
3311
                break;
3312
        }
3313
59
        if (j == oc->nb_streams)
3314
59
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
3315
50
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3316
59
                ost->st->disposition = AV_DISPOSITION_DEFAULT;
3317
    }
3318
3319
5712
    if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3320
4590
        if (!ost->frame_rate.num)
3321
4570
            ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3322

4590
        if (ist && !ost->frame_rate.num)
3323
            ost->frame_rate = ist->framerate;
3324

4590
        if (ist && !ost->frame_rate.num)
3325
            ost->frame_rate = ist->st->r_frame_rate;
3326

4590
        if (ist && !ost->frame_rate.num) {
3327
            ost->frame_rate = (AVRational){25, 1};
3328
            av_log(NULL, AV_LOG_WARNING,
3329
                   "No information "
3330
                   "about the input framerate is available. Falling "
3331
                   "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3332
                   "if you want a different framerate.\n",
3333
                   ost->file_index, ost->index);
3334
        }
3335
3336

4590
        if (ost->enc->supported_framerates && !ost->force_fps) {
3337
48
            int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3338
48
            ost->frame_rate = ost->enc->supported_framerates[idx];
3339
        }
3340
        // reduce frame rate for mpeg4 to be within the spec limits
3341
4590
        if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3342
58
            av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3343
58
                      ost->frame_rate.num, ost->frame_rate.den, 65535);
3344
        }
3345
    }
3346
3347

5712
    switch (enc_ctx->codec_type) {
3348
1092
    case AVMEDIA_TYPE_AUDIO:
3349
1092
        enc_ctx->sample_fmt     = av_buffersink_get_format(ost->filter->filter);
3350
1092
        if (dec_ctx)
3351
1083
            enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
3352
                                                 av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
3353
1092
        enc_ctx->sample_rate    = av_buffersink_get_sample_rate(ost->filter->filter);
3354
1092
        enc_ctx->channel_layout = av_buffersink_get_channel_layout(ost->filter->filter);
3355
1092
        enc_ctx->channels       = av_buffersink_get_channels(ost->filter->filter);
3356
3357
1092
        init_encoder_time_base(ost, av_make_q(1, enc_ctx->sample_rate));