GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg.c Lines: 2061 2753 74.9 %
Date: 2020-09-21 17:35:45 Branches: 1515 2153 70.4 %

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


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

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

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

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

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

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

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

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

442604
    if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
749

419276
        (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
750
23328
        pkt->pts = pkt->dts = AV_NOPTS_VALUE;
751
752
442604
    if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
753
        int i;
754
109366
        uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
755
                                              NULL);
756
109366
        ost->quality = sd ? AV_RL32(sd) : -1;
757
109366
        ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
758
759
546830
        for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
760

437464
            if (sd && i < sd[5])
761
                ost->error[i] = AV_RL64(sd + 8 + 8*i);
762
            else
763
437464
                ost->error[i] = -1;
764
        }
765
766

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

201192
        if ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO || st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) &&
789
201179
            pkt->dts != AV_NOPTS_VALUE &&
790

177851
            !(st->codecpar->codec_id == AV_CODEC_ID_VP9 && ost->stream_copy) &&
791
177618
            ost->last_mux_dts != AV_NOPTS_VALUE) {
792
173106
            int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
793
173106
            if (pkt->dts < max) {
794

2
                int loglevel = max - pkt->dts > 2 || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
795
2
                if (exit_on_error)
796
                    loglevel = AV_LOG_ERROR;
797
2
                av_log(s, loglevel, "Non-monotonous DTS in output stream "
798
                       "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
799
2
                       ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
800
2
                if (exit_on_error) {
801
                    av_log(NULL, AV_LOG_FATAL, "aborting.\n");
802
                    exit_program(1);
803
                }
804
2
                av_log(s, loglevel, "changing to %"PRId64". This may result "
805
                       "in incorrect timestamps in the output file.\n",
806
                       max);
807
2
                if (pkt->pts >= pkt->dts)
808
2
                    pkt->pts = FFMAX(pkt->pts, max);
809
2
                pkt->dts = max;
810
            }
811
        }
812
    }
813
442604
    ost->last_mux_dts = pkt->dts;
814
815
442604
    ost->data_size += pkt->size;
816
442604
    ost->packets_written++;
817
818
442604
    pkt->stream_index = ost->index;
819
820
442604
    if (debug_ts) {
821
        av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
822
                "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
823
                av_get_media_type_string(ost->enc_ctx->codec_type),
824
                av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
825
                av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
826
                pkt->size
827
              );
828
    }
829
830
442604
    ret = av_interleaved_write_frame(s, pkt);
831
442604
    if (ret < 0) {
832
1
        print_error("av_interleaved_write_frame()", ret);
833
1
        main_return_code = 1;
834
1
        close_all_output_streams(ost, MUXER_FINISHED | ENCODER_FINISHED, ENCODER_FINISHED);
835
    }
836
442604
    av_packet_unref(pkt);
837
}
838
839
5800
static void close_output_stream(OutputStream *ost)
840
{
841
5800
    OutputFile *of = output_files[ost->file_index];
842
843
5800
    ost->finished |= ENCODER_FINISHED;
844
5800
    if (of->shortest) {
845
        int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);
846
        of->recording_time = FFMIN(of->recording_time, end);
847
    }
848
5800
}
849
850
/*
851
 * Send a single packet to the output, applying any bitstream filters
852
 * associated with the output stream.  This may result in any number
853
 * of packets actually being written, depending on what bitstream
854
 * filters are applied.  The supplied packet is consumed and will be
855
 * blank (as if newly-allocated) when this function returns.
856
 *
857
 * If eof is set, instead indicate EOF to all bitstream filters and
858
 * therefore flush any delayed packets to the output.  A blank packet
859
 * must be supplied in this case.
860
 */
861
448709
static void output_packet(OutputFile *of, AVPacket *pkt,
862
                          OutputStream *ost, int eof)
863
{
864
448709
    int ret = 0;
865
866
    /* apply the output bitstream filters */
867
448709
    if (ost->bsf_ctx) {
868
6769
        ret = av_bsf_send_packet(ost->bsf_ctx, eof ? NULL : pkt);
869
6769
        if (ret < 0)
870
            goto finish;
871
13534
        while ((ret = av_bsf_receive_packet(ost->bsf_ctx, pkt)) >= 0)
872
6765
            write_packet(of, pkt, ost, 0);
873
6769
        if (ret == AVERROR(EAGAIN))
874
6765
            ret = 0;
875
441940
    } else if (!eof)
876
436156
        write_packet(of, pkt, ost, 0);
877
878
5784
finish:
879

448709
    if (ret < 0 && ret != AVERROR_EOF) {
880
1
        av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
881
               "packet for stream #%d:%d.\n", ost->file_index, ost->index);
882
1
        if(exit_on_error)
883
            exit_program(1);
884
    }
885
448709
}
886
887
417106
static int check_recording_time(OutputStream *ost)
888
{
889
417106
    OutputFile *of = output_files[ost->file_index];
890
891

424580
    if (of->recording_time != INT64_MAX &&
892
7474
        av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
893
7474
                      AV_TIME_BASE_Q) >= 0) {
894
1
        close_output_stream(ost);
895
1
        return 0;
896
    }
897
417105
    return 1;
898
}
899
900
317001
static void do_audio_out(OutputFile *of, OutputStream *ost,
901
                         AVFrame *frame)
902
{
903
317001
    AVCodecContext *enc = ost->enc_ctx;
904
    AVPacket pkt;
905
    int ret;
906
907
317001
    av_init_packet(&pkt);
908
317001
    pkt.data = NULL;
909
317001
    pkt.size = 0;
910
911
317001
    if (!check_recording_time(ost))
912
        return;
913
914

317001
    if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
915
        frame->pts = ost->sync_opts;
916
317001
    ost->sync_opts = frame->pts + frame->nb_samples;
917
317001
    ost->samples_encoded += frame->nb_samples;
918
317001
    ost->frames_encoded++;
919
920

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

101817
    if (frame_rate.num > 0 && frame_rate.den > 0)
1065
101688
        duration = 1/(av_q2d(frame_rate) * av_q2d(enc->time_base));
1066
1067


101817
    if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1068
65438
        duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
1069
1070
101817
    if (!ost->filters_script &&
1071
101720
        !ost->filters &&
1072

87053
        (nb_filtergraphs == 0 || !filtergraphs[0]->graph_desc) &&
1073
82833
        next_picture &&
1074
82833
        ist &&
1075
82833
        lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
1076
78154
        duration = lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
1077
    }
1078
1079
101817
    if (!next_picture) {
1080
        //end, flushing
1081
2418
        nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
1082
                                          ost->last_nb0_frames[1],
1083
                                          ost->last_nb0_frames[2]);
1084
    } else {
1085
99399
        delta0 = sync_ipts - ost->sync_opts; // delta0 is the "drift" between the input frame (next_picture) and where it would fall in the output.
1086
99399
        delta  = delta0 + duration;
1087
1088
        /* by default, we output a single frame */
1089
99399
        nb0_frames = 0; // tracks the number of times the PREVIOUS frame should be duplicated, mostly for variable framerate (VFR)
1090
99399
        nb_frames = 1;
1091
1092
99399
        format_video_sync = video_sync_method;
1093
99399
        if (format_video_sync == VSYNC_AUTO) {
1094
56372
            if(!strcmp(of->ctx->oformat->name, "avi")) {
1095
12650
                format_video_sync = VSYNC_VFR;
1096
            } else
1097

43722
                format_video_sync = (of->ctx->oformat->flags & AVFMT_VARIABLE_FPS) ? ((of->ctx->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
1098
56372
            if (   ist
1099
54921
                && format_video_sync == VSYNC_CFR
1100
9424
                && input_files[ist->file_index]->ctx->nb_streams == 1
1101
8349
                && input_files[ist->file_index]->input_ts_offset == 0) {
1102
8349
                format_video_sync = VSYNC_VSCFR;
1103
            }
1104

56372
            if (format_video_sync == VSYNC_CFR && copy_ts) {
1105
                format_video_sync = VSYNC_VSCFR;
1106
            }
1107
        }
1108

99399
        ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
1109
1110

99399
        if (delta0 < 0 &&
1111
11211
            delta > 0 &&
1112
10785
            format_video_sync != VSYNC_PASSTHROUGH &&
1113
            format_video_sync != VSYNC_DROP) {
1114
8016
            if (delta0 < -0.6) {
1115
431
                av_log(NULL, AV_LOG_VERBOSE, "Past duration %f too large\n", -delta0);
1116
            } else
1117
7585
                av_log(NULL, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
1118
8016
            sync_ipts = ost->sync_opts;
1119
8016
            duration += delta0;
1120
8016
            delta0 = 0;
1121
        }
1122
1123

99399
        switch (format_video_sync) {
1124
8349
        case VSYNC_VSCFR:
1125

8349
            if (ost->frame_number == 0 && delta0 >= 0.5) {
1126
                av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
1127
                delta = duration;
1128
                delta0 = 0;
1129
                ost->sync_opts = llrint(sync_ipts);
1130
            }
1131
        case VSYNC_CFR:
1132
            // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1133

9578
            if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
1134
                nb_frames = 0;
1135
9578
            } else if (delta < -1.1)
1136
                nb_frames = 0;
1137
9578
            else if (delta > 1.1) {
1138
350
                nb_frames = lrintf(delta);
1139
350
                if (delta0 > 1.1)
1140
2
                    nb0_frames = llrintf(delta0 - 0.6);
1141
            }
1142
9578
            break;
1143
46941
        case VSYNC_VFR:
1144
46941
            if (delta <= -0.6)
1145
170
                nb_frames = 0;
1146
46771
            else if (delta > 0.6)
1147
46189
                ost->sync_opts = llrint(sync_ipts);
1148
46941
            break;
1149
42880
        case VSYNC_DROP:
1150
        case VSYNC_PASSTHROUGH:
1151
42880
            ost->sync_opts = llrint(sync_ipts);
1152
42880
            break;
1153
        default:
1154
            av_assert0(0);
1155
        }
1156
    }
1157
1158
101817
    nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1159
101817
    nb0_frames = FFMIN(nb0_frames, nb_frames);
1160
1161
101817
    memmove(ost->last_nb0_frames + 1,
1162
101817
            ost->last_nb0_frames,
1163
            sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
1164
101817
    ost->last_nb0_frames[0] = nb0_frames;
1165
1166

101817
    if (nb0_frames == 0 && ost->last_dropped) {
1167
170
        nb_frames_drop++;
1168
170
        av_log(NULL, AV_LOG_VERBOSE,
1169
               "*** dropping frame %d from stream %d at ts %"PRId64"\n",
1170
170
               ost->frame_number, ost->st->index, ost->last_frame->pts);
1171
    }
1172

101817
    if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) {
1173
49
        if (nb_frames > dts_error_threshold * 30) {
1174
            av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
1175
            nb_frames_drop++;
1176
            return;
1177
        }
1178

49
        nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
1179
49
        av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1180
49
        if (nb_frames_dup > dup_warning) {
1181
            av_log(NULL, AV_LOG_WARNING, "More than %d frames duplicated\n", dup_warning);
1182
            dup_warning *= 10;
1183
        }
1184
    }
1185

101817
    ost->last_dropped = nb_frames == nb0_frames && next_picture;
1186
1187
    /* duplicates frame if needed */
1188
201254
    for (i = 0; i < nb_frames; i++) {
1189
        AVFrame *in_picture;
1190
99438
        int forced_keyframe = 0;
1191
        double pts_time;
1192
99438
        av_init_packet(&pkt);
1193
99438
        pkt.data = NULL;
1194
99438
        pkt.size = 0;
1195
1196

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

99218
            if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
1300
                pkt.pts = ost->sync_opts;
1301
1302
99218
            av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1303
1304
99218
            if (debug_ts) {
1305
                av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1306
                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1307
                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->mux_timebase),
1308
                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->mux_timebase));
1309
            }
1310
1311
99218
            frame_size = pkt.size;
1312
99218
            output_packet(of, &pkt, ost, 0);
1313
1314
            /* if two pass, output log */
1315

99218
            if (ost->logfile && enc->stats_out) {
1316
                fprintf(ost->logfile, "%s", enc->stats_out);
1317
            }
1318
        }
1319
99437
        ost->sync_opts++;
1320
        /*
1321
         * For video, number of frames in == number of packets out.
1322
         * But there may be reordering, so we can't throw away frames on encoder
1323
         * flush, we need to limit them here, before they go into encoder.
1324
         */
1325
99437
        ost->frame_number++;
1326
1327

99437
        if (vstats_filename && frame_size)
1328
            do_video_stats(ost, frame_size);
1329
    }
1330
1331
101816
    if (!ost->last_frame)
1332
4749
        ost->last_frame = av_frame_alloc();
1333
101816
    av_frame_unref(ost->last_frame);
1334

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

440462
        if (!ost->filter || !ost->filter->graph->graph)
1428
48102
            continue;
1429
392360
        filter = ost->filter->filter;
1430
1431
392360
        if (!ost->initialized) {
1432
5746
            char error[1024] = "";
1433
5746
            ret = init_output_stream(ost, error, sizeof(error));
1434
5746
            if (ret < 0) {
1435
                av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1436
                       ost->file_index, ost->index, error);
1437
                exit_program(1);
1438
            }
1439
        }
1440
1441

392360
        if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
1442
            return AVERROR(ENOMEM);
1443
        }
1444
392360
        filtered_frame = ost->filtered_frame;
1445
1446
416400
        while (1) {
1447
808760
            double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
1448
808760
            ret = av_buffersink_get_frame_flags(filter, filtered_frame,
1449
                                               AV_BUFFERSINK_FLAG_NO_REQUEST);
1450
808760
            if (ret < 0) {
1451

392360
                if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1452
                    av_log(NULL, AV_LOG_WARNING,
1453
                           "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1454

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

6116
        switch (ost->enc_ctx->codec_type) {
1530
4840
            case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1531
1227
            case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1532
38
            case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1533
11
            default:                 other_size += ost->data_size; break;
1534
        }
1535
6116
        extra_size += ost->enc_ctx->extradata_size;
1536
6116
        data_size  += ost->data_size;
1537
6116
        if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2))
1538
            != AV_CODEC_FLAG_PASS1)
1539
6116
            pass1_used = 0;
1540
    }
1541
1542

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

1051596
    if (!print_stats && !is_last_report && !progress_avio)
1654
1045602
        return;
1655
1656
16361
    if (!is_last_report) {
1657
10393
        if (last_time == -1) {
1658
32
            last_time = cur_time;
1659
32
            return;
1660
        }
1661
10361
        if ((cur_time - last_time) < 500000)
1662
10335
            return;
1663
26
        last_time = cur_time;
1664
    }
1665
1666
5994
    t = (cur_time-timer_start) / 1000000.0;
1667
1668
1669
5994
    oc = output_files[0]->ctx;
1670
1671
5994
    total_size = avio_size(oc->pb);
1672
5994
    if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1673
78
        total_size = avio_tell(oc->pb);
1674
1675
5994
    vid = 0;
1676
5994
    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1677
5994
    av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
1678
12136
    for (i = 0; i < nb_output_streams; i++) {
1679
6142
        float q = -1;
1680
6142
        ost = output_streams[i];
1681
6142
        enc = ost->enc_ctx;
1682
6142
        if (!ost->stream_copy)
1683
5845
            q = ost->quality / (float) FF_QP2LAMBDA;
1684
1685

6142
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1686
8
            av_bprintf(&buf, "q=%2.1f ", q);
1687
8
            av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1688
                       ost->file_index, ost->index, q);
1689
        }
1690

6142
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1691
            float fps;
1692
1693
4833
            frame_number = ost->frame_number;
1694
4833
            fps = t > 1 ? frame_number / t : 0;
1695
4833
            av_bprintf(&buf, "frame=%5d fps=%3.*f q=%3.1f ",
1696
                     frame_number, fps < 9.95, fps, q);
1697
4833
            av_bprintf(&buf_script, "frame=%d\n", frame_number);
1698
4833
            av_bprintf(&buf_script, "fps=%.2f\n", fps);
1699
4833
            av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1700
                       ost->file_index, ost->index, q);
1701
4833
            if (is_last_report)
1702
4832
                av_bprintf(&buf, "L");
1703
4833
            if (qp_hist) {
1704
                int j;
1705
                int qp = lrintf(q);
1706
                if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1707
                    qp_histogram[qp]++;
1708
                for (j = 0; j < 32; j++)
1709
                    av_bprintf(&buf, "%X", av_log2(qp_histogram[j] + 1));
1710
            }
1711
1712

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

5994
    bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1760
5994
    speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
1761
1762
5994
    if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
1763
5917
    else                av_bprintf(&buf, "size=%8.0fkB time=", total_size / 1024.0);
1764
5994
    if (pts == AV_NOPTS_VALUE) {
1765
        av_bprintf(&buf, "N/A ");
1766
    } else {
1767
5994
        av_bprintf(&buf, "%s%02d:%02d:%02d.%02d ",
1768
                   hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
1769
    }
1770
1771
5994
    if (bitrate < 0) {
1772
89
        av_bprintf(&buf, "bitrate=N/A");
1773
89
        av_bprintf(&buf_script, "bitrate=N/A\n");
1774
    }else{
1775
5905
        av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
1776
5905
        av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1777
    }
1778
1779
5994
    if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1780
5917
    else                av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1781
5994
    if (pts == AV_NOPTS_VALUE) {
1782
        av_bprintf(&buf_script, "out_time_us=N/A\n");
1783
        av_bprintf(&buf_script, "out_time_ms=N/A\n");
1784
        av_bprintf(&buf_script, "out_time=N/A\n");
1785
    } else {
1786
5994
        av_bprintf(&buf_script, "out_time_us=%"PRId64"\n", pts);
1787
5994
        av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1788
5994
        av_bprintf(&buf_script, "out_time=%s%02d:%02d:%02d.%06d\n",
1789
                   hours_sign, hours, mins, secs, us);
1790
    }
1791
1792

5994
    if (nb_frames_dup || nb_frames_drop)
1793
26
        av_bprintf(&buf, " dup=%d drop=%d", nb_frames_dup, nb_frames_drop);
1794
5994
    av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1795
5994
    av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1796
1797
5994
    if (speed < 0) {
1798
1
        av_bprintf(&buf, " speed=N/A");
1799
1
        av_bprintf(&buf_script, "speed=N/A\n");
1800
    } else {
1801
5993
        av_bprintf(&buf, " speed=%4.3gx", speed);
1802
5993
        av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
1803
    }
1804
1805

5994
    if (print_stats || is_last_report) {
1806
5994
        const char end = is_last_report ? '\n' : '\r';
1807

5994
        if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
1808
            fprintf(stderr, "%s    %c", buf.str, end);
1809
        } else
1810
5994
            av_log(NULL, AV_LOG_INFO, "%s    %c", buf.str, end);
1811
1812
5994
        fflush(stderr);
1813
    }
1814
5994
    av_bprint_finalize(&buf, NULL);
1815
1816
5994
    if (progress_avio) {
1817
        av_bprintf(&buf_script, "progress=%s\n",
1818
                   is_last_report ? "end" : "continue");
1819
        avio_write(progress_avio, buf_script.str,
1820
                   FFMIN(buf_script.len, buf_script.size - 1));
1821
        avio_flush(progress_avio);
1822
        av_bprint_finalize(&buf_script, NULL);
1823
        if (is_last_report) {
1824
            if ((ret = avio_closep(&progress_avio)) < 0)
1825
                av_log(NULL, AV_LOG_ERROR,
1826
                       "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
1827
        }
1828
    }
1829
1830
5994
    if (is_last_report)
1831
5968
        print_final_stats(total_size);
1832
}
1833
1834
1
static void ifilter_parameters_from_codecpar(InputFilter *ifilter, AVCodecParameters *par)
1835
{
1836
    // We never got any input. Set a fake format, which will
1837
    // come from libavformat.
1838
1
    ifilter->format                 = par->format;
1839
1
    ifilter->sample_rate            = par->sample_rate;
1840
1
    ifilter->channels               = par->channels;
1841
1
    ifilter->channel_layout         = par->channel_layout;
1842
1
    ifilter->width                  = par->width;
1843
1
    ifilter->height                 = par->height;
1844
1
    ifilter->sample_aspect_ratio    = par->sample_aspect_ratio;
1845
1
}
1846
1847
5970
static void flush_encoders(void)
1848
{
1849
    int i, ret;
1850
1851
12086
    for (i = 0; i < nb_output_streams; i++) {
1852
6118
        OutputStream   *ost = output_streams[i];
1853
6118
        AVCodecContext *enc = ost->enc_ctx;
1854
6118
        OutputFile      *of = output_files[ost->file_index];
1855
1856
6118
        if (!ost->encoding_needed)
1857
298
            continue;
1858
1859
        // Try to enable encoding with no input frames.
1860
        // Maybe we should just let encoding fail instead.
1861
5820
        if (!ost->initialized) {
1862
2
            FilterGraph *fg = ost->filter->graph;
1863
2
            char error[1024] = "";
1864
1865
2
            av_log(NULL, AV_LOG_WARNING,
1866
                   "Finishing stream %d:%d without any data written to it.\n",
1867
2
                   ost->file_index, ost->st->index);
1868
1869

2
            if (ost->filter && !fg->graph) {
1870
                int x;
1871
2
                for (x = 0; x < fg->nb_inputs; x++) {
1872
                    InputFilter *ifilter = fg->inputs[x];
1873
                    if (ifilter->format < 0)
1874
                        ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
1875
                }
1876
1877
2
                if (!ifilter_has_all_input_formats(fg))
1878
                    continue;
1879
1880
2
                ret = configure_filtergraph(fg);
1881
2
                if (ret < 0) {
1882
2
                    av_log(NULL, AV_LOG_ERROR, "Error configuring filter graph\n");
1883
2
                    exit_program(1);
1884
                }
1885
1886
                finish_output_stream(ost);
1887
            }
1888
1889
            ret = init_output_stream(ost, error, sizeof(error));
1890
            if (ret < 0) {
1891
                av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1892
                       ost->file_index, ost->index, error);
1893
                exit_program(1);
1894
            }
1895
        }
1896
1897

5818
        if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
1898
31
            continue;
1899
1900
261
        for (;;) {
1901
6048
            const char *desc = NULL;
1902
            AVPacket pkt;
1903
            int pkt_size;
1904
1905
6048
            switch (enc->codec_type) {
1906
1160
            case AVMEDIA_TYPE_AUDIO:
1907
1160
                desc   = "audio";
1908
1160
                break;
1909
4888
            case AVMEDIA_TYPE_VIDEO:
1910
4888
                desc   = "video";
1911
4888
                break;
1912
            default:
1913
                av_assert0(0);
1914
            }
1915
1916
6048
            av_init_packet(&pkt);
1917
6048
            pkt.data = NULL;
1918
6048
            pkt.size = 0;
1919
1920
6048
            update_benchmark(NULL);
1921
1922
11835
            while ((ret = avcodec_receive_packet(enc, &pkt)) == AVERROR(EAGAIN)) {
1923
5787
                ret = avcodec_send_frame(enc, NULL);
1924
5787
                if (ret < 0) {
1925
                    av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1926
                           desc,
1927
                           av_err2str(ret));
1928
                    exit_program(1);
1929
                }
1930
            }
1931
1932
6048
            update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
1933

6048
            if (ret < 0 && ret != AVERROR_EOF) {
1934
                av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1935
                       desc,
1936
                       av_err2str(ret));
1937
                exit_program(1);
1938
            }
1939

6048
            if (ost->logfile && enc->stats_out) {
1940
                fprintf(ost->logfile, "%s", enc->stats_out);
1941
            }
1942
6048
            if (ret == AVERROR_EOF) {
1943
5787
                output_packet(of, &pkt, ost, 1);
1944
5787
                break;
1945
            }
1946
261
            if (ost->finished & MUXER_FINISHED) {
1947
                av_packet_unref(&pkt);
1948
                continue;
1949
            }
1950
261
            av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1951
261
            pkt_size = pkt.size;
1952
261
            output_packet(of, &pkt, ost, 0);
1953

261
            if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1954
                do_video_stats(ost, pkt_size);
1955
            }
1956
        }
1957
    }
1958
5968
}
1959
1960
/*
1961
 * Check whether a packet from ist should be written into ost at this time
1962
 */
1963
428207
static int check_output_constraints(InputStream *ist, OutputStream *ost)
1964
{
1965
428207
    OutputFile *of = output_files[ost->file_index];
1966
428207
    int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1967
1968
428207
    if (ost->source_index != ist_index)
1969
17092
        return 0;
1970
1971
411115
    if (ost->finished)
1972
2880
        return 0;
1973
1974

408235
    if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1975
        return 0;
1976
1977
408235
    return 1;
1978
}
1979
1980
31951
static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1981
{
1982
31951
    OutputFile *of = output_files[ost->file_index];
1983
31951
    InputFile   *f = input_files [ist->file_index];
1984
31951
    int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1985
31951
    int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
1986
    AVPacket opkt;
1987
1988
    // EOF: flush output bitstream filters.
1989
31951
    if (!pkt) {
1990
        av_init_packet(&opkt);
1991
        opkt.data = NULL;
1992
        opkt.size = 0;
1993
        output_packet(of, &opkt, ost, 1);
1994
20
        return;
1995
    }
1996
1997

31951
    if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1998
12
        !ost->copy_initial_nonkeyframes)
1999
12
        return;
2000
2001

31939
    if (!ost->frame_number && !ost->copy_prior_start) {
2002
        int64_t comp_start = start_time;
2003
        if (copy_ts && f->start_time != AV_NOPTS_VALUE)
2004
            comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
2005
        if (pkt->pts == AV_NOPTS_VALUE ?
2006
            ist->pts < comp_start :
2007
            pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
2008
            return;
2009
    }
2010
2011
31939
    if (of->recording_time != INT64_MAX &&
2012
446
        ist->pts >= of->recording_time + start_time) {
2013
6
        close_output_stream(ost);
2014
6
        return;
2015
    }
2016
2017
31933
    if (f->recording_time != INT64_MAX) {
2018
148
        start_time = f->ctx->start_time;
2019

148
        if (f->start_time != AV_NOPTS_VALUE && copy_ts)
2020
74
            start_time += f->start_time;
2021
148
        if (ist->pts >= f->recording_time + start_time) {
2022
2
            close_output_stream(ost);
2023
2
            return;
2024
        }
2025
    }
2026
2027
    /* force the input stream PTS */
2028
31931
    if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2029
9930
        ost->sync_opts++;
2030
2031
31931
    if (av_packet_ref(&opkt, pkt) < 0)
2032
        exit_program(1);
2033
2034
31931
    if (pkt->pts != AV_NOPTS_VALUE)
2035
26479
        opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
2036
2037
31931
    if (pkt->dts == AV_NOPTS_VALUE) {
2038
5200
        opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->mux_timebase);
2039
26731
    } else if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2040
21470
        int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
2041
21470
        if(!duration)
2042
8308
            duration = ist->dec_ctx->frame_size;
2043
42940
        opkt.dts = av_rescale_delta(ist->st->time_base, pkt->dts,
2044
21470
                                    (AVRational){1, ist->dec_ctx->sample_rate}, duration,
2045
                                    &ist->filter_in_rescale_delta_last, ost->mux_timebase);
2046
        /* dts will be set immediately afterwards to what pts is now */
2047
21470
        opkt.pts = opkt.dts - ost_tb_start_time;
2048
    } else
2049
5261
        opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
2050
31931
    opkt.dts -= ost_tb_start_time;
2051
2052
31931
    opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
2053
2054
31931
    output_packet(of, &opkt, ost, 0);
2055
}
2056
2057
1373
int guess_input_channel_layout(InputStream *ist)
2058
{
2059
1373
    AVCodecContext *dec = ist->dec_ctx;
2060
2061
1373
    if (!dec->channel_layout) {
2062
        char layout_name[256];
2063
2064
746
        if (dec->channels > ist->guess_layout_max)
2065
7
            return 0;
2066
742
        dec->channel_layout = av_get_default_channel_layout(dec->channels);
2067
742
        if (!dec->channel_layout)
2068
3
            return 0;
2069
739
        av_get_channel_layout_string(layout_name, sizeof(layout_name),
2070
                                     dec->channels, dec->channel_layout);
2071
739
        av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2072
739
               "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2073
    }
2074
1366
    return 1;
2075
}
2076
2077
768291
static void check_decode_result(InputStream *ist, int *got_output, int ret)
2078
{
2079

768291
    if (*got_output || ret<0)
2080
395991
        decode_error_stat[ret<0] ++;
2081
2082

768291
    if (ret < 0 && exit_on_error)
2083
        exit_program(1);
2084
2085

768291
    if (*got_output && ist) {
2086

394843
        if (ist->decoded_frame->decode_error_flags || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
2087
36
            av_log(NULL, exit_on_error ? AV_LOG_FATAL : AV_LOG_WARNING,
2088
36
                   "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->url, ist->st->index);
2089
36
            if (exit_on_error)
2090
                exit_program(1);
2091
        }
2092
    }
2093
768291
}
2094
2095
// Filters can be configured only if the formats of all inputs are known.
2096
635583
static int ifilter_has_all_input_formats(FilterGraph *fg)
2097
{
2098
    int i;
2099
653661
    for (i = 0; i < fg->nb_inputs; i++) {
2100

647815
        if (fg->inputs[i]->format < 0 && (fg->inputs[i]->type == AVMEDIA_TYPE_AUDIO ||
2101
629718
                                          fg->inputs[i]->type == AVMEDIA_TYPE_VIDEO))
2102
629737
            return 0;
2103
    }
2104
5846
    return 1;
2105
}
2106
2107
395243
static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
2108
{
2109
395243
    FilterGraph *fg = ifilter->graph;
2110
    int need_reinit, ret, i;
2111
2112
    /* determine if the parameters for this input changed */
2113
395243
    need_reinit = ifilter->format != frame->format;
2114
2115
395243
    switch (ifilter->ist->st->codecpar->codec_type) {
2116
296110
    case AVMEDIA_TYPE_AUDIO:
2117
887210
        need_reinit |= ifilter->sample_rate    != frame->sample_rate ||
2118

591099
                       ifilter->channels       != frame->channels ||
2119
294989
                       ifilter->channel_layout != frame->channel_layout;
2120
296110
        break;
2121
99133
    case AVMEDIA_TYPE_VIDEO:
2122
193601
        need_reinit |= ifilter->width  != frame->width ||
2123
94468
                       ifilter->height != frame->height;
2124
99133
        break;
2125
    }
2126
2127

395243
    if (!ifilter->ist->reinit_filters && fg->graph)
2128
        need_reinit = 0;
2129
2130
395243
    if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
2131

395243
        (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
2132
        need_reinit = 1;
2133
2134
395243
    if (need_reinit) {
2135
5799
        ret = ifilter_parameters_from_frame(ifilter, frame);
2136
5799
        if (ret < 0)
2137
            return ret;
2138
    }
2139
2140
    /* (re)init the graph if possible, otherwise buffer the frame and return */
2141

395243
    if (need_reinit || !fg->graph) {
2142
11600
        for (i = 0; i < fg->nb_inputs; i++) {
2143
5820
            if (!ifilter_has_all_input_formats(fg)) {
2144
19
                AVFrame *tmp = av_frame_clone(frame);
2145
19
                if (!tmp)
2146
                    return AVERROR(ENOMEM);
2147
19
                av_frame_unref(frame);
2148
2149
19
                if (!av_fifo_space(ifilter->frame_queue)) {
2150
                    ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
2151
                    if (ret < 0) {
2152
                        av_frame_free(&tmp);
2153
                        return ret;
2154
                    }
2155
                }
2156
19
                av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
2157
19
                return 0;
2158
            }
2159
        }
2160
2161
5780
        ret = reap_filters(1);
2162

5780
        if (ret < 0 && ret != AVERROR_EOF) {
2163
            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2164
            return ret;
2165
        }
2166
2167
5780
        ret = configure_filtergraph(fg);
2168
5780
        if (ret < 0) {
2169
            av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
2170
            return ret;
2171
        }
2172
    }
2173
2174
395224
    ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, AV_BUFFERSRC_FLAG_PUSH);
2175
395224
    if (ret < 0) {
2176
        if (ret != AVERROR_EOF)
2177
            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2178
        return ret;
2179
    }
2180
2181
395224
    return 0;
2182
}
2183
2184
5752
static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
2185
{
2186
    int ret;
2187
2188
5752
    ifilter->eof = 1;
2189
2190
5752
    if (ifilter->filter) {
2191
5751
        ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH);
2192
5751
        if (ret < 0)
2193
            return ret;
2194
    } else {
2195
        // the filtergraph was never configured
2196
1
        if (ifilter->format < 0)
2197
1
            ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
2198

1
        if (ifilter->format < 0 && (ifilter->type == AVMEDIA_TYPE_AUDIO || ifilter->type == AVMEDIA_TYPE_VIDEO)) {
2199
            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);
2200
            return AVERROR_INVALIDDATA;
2201
        }
2202
    }
2203
2204
5752
    return 0;
2205
}
2206
2207
// This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
2208
// There is the following difference: if you got a frame, you must call
2209
// it again with pkt=NULL. pkt==NULL is treated differently from pkt->size==0
2210
// (pkt==NULL means get more output, pkt->size==0 is a flush/drain packet)
2211
772765
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
2212
{
2213
    int ret;
2214
2215
772765
    *got_frame = 0;
2216
2217
772765
    if (pkt) {
2218
378594
        ret = avcodec_send_packet(avctx, pkt);
2219
        // In particular, we don't expect AVERROR(EAGAIN), because we read all
2220
        // decoded frames with avcodec_receive_frame() until done.
2221

378594
        if (ret < 0 && ret != AVERROR_EOF)
2222
379
            return ret;
2223
    }
2224
2225
772386
    ret = avcodec_receive_frame(avctx, frame);
2226

772386
    if (ret < 0 && ret != AVERROR(EAGAIN))
2227
5751
        return ret;
2228
766635
    if (ret >= 0)
2229
394843
        *got_frame = 1;
2230
2231
766635
    return 0;
2232
}
2233
2234
394843
static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
2235
{
2236
    int i, ret;
2237
    AVFrame *f;
2238
2239
    av_assert1(ist->nb_filters > 0); /* ensure ret is initialized */
2240
790086
    for (i = 0; i < ist->nb_filters; i++) {
2241
395243
        if (i < ist->nb_filters - 1) {
2242
400
            f = ist->filter_frame;
2243
400
            ret = av_frame_ref(f, decoded_frame);
2244
400
            if (ret < 0)
2245
                break;
2246
        } else
2247
394843
            f = decoded_frame;
2248
395243
        ret = ifilter_send_frame(ist->filters[i], f);
2249
395243
        if (ret == AVERROR_EOF)
2250
            ret = 0; /* ignore */
2251
395243
        if (ret < 0) {
2252
            av_log(NULL, AV_LOG_ERROR,
2253
                   "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2254
            break;
2255
        }
2256
    }
2257
394843
    return ret;
2258
}
2259
2260
565764
static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
2261
                        int *decode_failed)
2262
{
2263
    AVFrame *decoded_frame;
2264
565764
    AVCodecContext *avctx = ist->dec_ctx;
2265
565764
    int ret, err = 0;
2266
    AVRational decoded_frame_tb;
2267
2268

565764
    if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2269
        return AVERROR(ENOMEM);
2270

565764
    if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2271
        return AVERROR(ENOMEM);
2272
565764
    decoded_frame = ist->decoded_frame;
2273
2274
565764
    update_benchmark(NULL);
2275
565764
    ret = decode(avctx, decoded_frame, got_output, pkt);
2276
565764
    update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2277
565764
    if (ret < 0)
2278
1128
        *decode_failed = 1;
2279
2280

565764
    if (ret >= 0 && avctx->sample_rate <= 0) {
2281
        av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2282
        ret = AVERROR_INVALIDDATA;
2283
    }
2284
2285
565764
    if (ret != AVERROR_EOF)
2286
564646
        check_decode_result(ist, got_output, ret);
2287
2288

565764
    if (!*got_output || ret < 0)
2289
270054
        return ret;
2290
2291
295710
    ist->samples_decoded += decoded_frame->nb_samples;
2292
295710
    ist->frames_decoded++;
2293
2294
    /* increment next_dts to use for the case where the input stream does not
2295
       have timestamps or there are multiple frames in the packet */
2296
295710
    ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2297
295710
                     avctx->sample_rate;
2298
295710
    ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2299
295710
                     avctx->sample_rate;
2300
2301
295710
    if (decoded_frame->pts != AV_NOPTS_VALUE) {
2302
267462
        decoded_frame_tb   = ist->st->time_base;
2303

28248
    } else if (pkt && pkt->pts != AV_NOPTS_VALUE) {
2304
3
        decoded_frame->pts = pkt->pts;
2305
3
        decoded_frame_tb   = ist->st->time_base;
2306
    }else {
2307
28245
        decoded_frame->pts = ist->dts;
2308
28245
        decoded_frame_tb   = AV_TIME_BASE_Q;
2309
    }
2310
295710
    if (decoded_frame->pts != AV_NOPTS_VALUE)
2311
295710
        decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
2312
295710
                                              (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2313
295710
                                              (AVRational){1, avctx->sample_rate});
2314
295710
    ist->nb_samples = decoded_frame->nb_samples;
2315
295710
    err = send_frame_to_filters(ist, decoded_frame);
2316
2317
295710
    av_frame_unref(ist->filter_frame);
2318
295710
    av_frame_unref(decoded_frame);
2319
295710
    return err < 0 ? err : ret;
2320
}
2321
2322
208546
static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *duration_pts, int eof,
2323
                        int *decode_failed)
2324
{
2325
    AVFrame *decoded_frame;
2326
208546
    int i, ret = 0, err = 0;
2327
    int64_t best_effort_timestamp;
2328
208546
    int64_t dts = AV_NOPTS_VALUE;
2329
    AVPacket avpkt;
2330
2331
    // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
2332
    // reason. This seems like a semi-critical bug. Don't trigger EOF, and
2333
    // skip the packet.
2334

208546
    if (!eof && pkt && pkt->size == 0)
2335
1545
        return 0;
2336
2337

207001
    if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2338
        return AVERROR(ENOMEM);
2339

207001
    if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2340
        return AVERROR(ENOMEM);
2341
207001
    decoded_frame = ist->decoded_frame;
2342
207001
    if (ist->dts != AV_NOPTS_VALUE)
2343
206590
        dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2344
207001
    if (pkt) {
2345
108512
        avpkt = *pkt;
2346
108512
        avpkt.dts = dts; // ffmpeg.c probably shouldn't do this
2347
    }
2348
2349
    // The old code used to set dts on the drain packet, which does not work
2350
    // with the new API anymore.
2351
207001
    if (eof) {
2352
5272
        void *new = av_realloc_array(ist->dts_buffer, ist->nb_dts_buffer + 1, sizeof(ist->dts_buffer[0]));
2353
5272
        if (!new)
2354
            return AVERROR(ENOMEM);
2355
5272
        ist->dts_buffer = new;
2356
5272
        ist->dts_buffer[ist->nb_dts_buffer++] = dts;
2357
    }
2358
2359
207001
    update_benchmark(NULL);
2360
207001
    ret = decode(ist->dec_ctx, decoded_frame, got_output, pkt ? &avpkt : NULL);
2361
207001
    update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2362
207001
    if (ret < 0)
2363
5002
        *decode_failed = 1;
2364
2365
    // The following line may be required in some cases where there is no parser
2366
    // or the parser does not has_b_frames correctly
2367
207001
    if (ist->st->codecpar->video_delay < ist->dec_ctx->has_b_frames) {
2368
1
        if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2369
1
            ist->st->codecpar->video_delay = ist->dec_ctx->has_b_frames;
2370
        } else
2371
            av_log(ist->dec_ctx, AV_LOG_WARNING,
2372
                   "video_delay is larger in decoder than demuxer %d > %d.\n"
2373
                   "If you want to help, upload a sample "
2374
                   "of this file to https://streams.videolan.org/upload/ "
2375
                   "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
2376
                   ist->dec_ctx->has_b_frames,
2377
                   ist->st->codecpar->video_delay);
2378
    }
2379
2380
207001
    if (ret != AVERROR_EOF)
2381
202373
        check_decode_result(ist, got_output, ret);
2382
2383

207001
    if (*got_output && ret >= 0) {
2384
99133
        if (ist->dec_ctx->width  != decoded_frame->width ||
2385
99124
            ist->dec_ctx->height != decoded_frame->height ||
2386
99122
            ist->dec_ctx->pix_fmt != decoded_frame->format) {
2387
15
            av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2388
                decoded_frame->width,
2389
                decoded_frame->height,
2390
                decoded_frame->format,
2391
15
                ist->dec_ctx->width,
2392
15
                ist->dec_ctx->height,
2393
15
                ist->dec_ctx->pix_fmt);
2394
        }
2395
    }
2396
2397

207001
    if (!*got_output || ret < 0)
2398
107868
        return ret;
2399
2400
99133
    if(ist->top_field_first>=0)
2401
        decoded_frame->top_field_first = ist->top_field_first;
2402
2403
99133
    ist->frames_decoded++;
2404
2405

99133
    if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2406
        err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2407
        if (err < 0)
2408
            goto fail;
2409
    }
2410
99133
    ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2411
2412
99133
    best_effort_timestamp= decoded_frame->best_effort_timestamp;
2413
99133
    *duration_pts = decoded_frame->pkt_duration;
2414
2415
99133
    if (ist->framerate.num)
2416
103
        best_effort_timestamp = ist->cfr_next_pts++;
2417
2418

99133
    if (eof && best_effort_timestamp == AV_NOPTS_VALUE && ist->nb_dts_buffer > 0) {
2419
527
        best_effort_timestamp = ist->dts_buffer[0];
2420
2421
527
        for (i = 0; i < ist->nb_dts_buffer - 1; i++)
2422
            ist->dts_buffer[i] = ist->dts_buffer[i + 1];
2423
527
        ist->nb_dts_buffer--;
2424
    }
2425
2426
99133
    if(best_effort_timestamp != AV_NOPTS_VALUE) {
2427
99133
        int64_t ts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2428
2429
99133
        if (ts != AV_NOPTS_VALUE)
2430
99133
            ist->next_pts = ist->pts = ts;
2431
    }
2432
2433
99133
    if (debug_ts) {
2434
        av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2435
               "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",
2436
               ist->st->index, av_ts2str(decoded_frame->pts),
2437
               av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2438
               best_effort_timestamp,
2439
               av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2440
               decoded_frame->key_frame, decoded_frame->pict_type,
2441
               ist->st->time_base.num, ist->st->time_base.den);
2442
    }
2443
2444
99133
    if (ist->st->sample_aspect_ratio.num)
2445
4947
        decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2446
2447
99133
    err = send_frame_to_filters(ist, decoded_frame);
2448
2449
99133
fail:
2450
99133
    av_frame_unref(ist->filter_frame);
2451
99133
    av_frame_unref(decoded_frame);
2452
99133
    return err < 0 ? err : ret;
2453
}
2454
2455
1272
static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
2456
                               int *decode_failed)
2457
{
2458
    AVSubtitle subtitle;
2459
1272
    int free_sub = 1;
2460
1272
    int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2461
                                          &subtitle, got_output, pkt);
2462
2463
1272
    check_decode_result(NULL, got_output, ret);
2464
2465

1272
    if (ret < 0 || !*got_output) {
2466
587
        *decode_failed = 1;
2467
587
        if (!pkt->size)
2468
34
            sub2video_flush(ist);
2469
587
        return ret;
2470
    }
2471
2472
685
    if (ist->fix_sub_duration) {
2473
        int end = 1;
2474
        if (ist->prev_sub.got_output) {
2475
            end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2476
                             1000, AV_TIME_BASE);
2477
            if (end < ist->prev_sub.subtitle.end_display_time) {
2478
                av_log(ist->dec_ctx, AV_LOG_DEBUG,
2479
                       "Subtitle duration reduced from %"PRId32" to %d%s\n",
2480
                       ist->prev_sub.subtitle.end_display_time, end,
2481
                       end <= 0 ? ", dropping it" : "");
2482
                ist->prev_sub.subtitle.end_display_time = end;
2483
            }
2484
        }
2485
        FFSWAP(int,        *got_output, ist->prev_sub.got_output);
2486
        FFSWAP(int,        ret,         ist->prev_sub.ret);
2487
        FFSWAP(AVSubtitle, subtitle,    ist->prev_sub.subtitle);
2488
        if (end <= 0)
2489
            goto out;
2490
    }
2491
2492
685
    if (!*got_output)
2493
        return ret;
2494
2495
685
    if (ist->sub2video.frame) {
2496
88
        sub2video_update(ist, INT64_MIN, &subtitle);
2497
597
    } else if (ist->nb_filters) {
2498
        if (!ist->sub2video.sub_queue)
2499
            ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
2500
        if (!ist->sub2video.sub_queue)
2501
            exit_program(1);
2502
        if (!av_fifo_space(ist->sub2video.sub_queue)) {
2503
            ret = av_fifo_realloc2(ist->sub2video.sub_queue, 2 * av_fifo_size(ist->sub2video.sub_queue));
2504
            if (ret < 0)
2505
                exit_program(1);
2506
        }
2507
        av_fifo_generic_write(ist->sub2video.sub_queue, &subtitle, sizeof(subtitle), NULL);
2508
        free_sub = 0;
2509
    }
2510
2511
685
    if (!subtitle.num_rects)
2512
9
        goto out;
2513
2514
676
    ist->frames_decoded++;
2515
2516
1396
    for (i = 0; i < nb_output_streams; i++) {
2517
720
        OutputStream *ost = output_streams[i];
2518
2519

720
        if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2520
675
            || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2521
89
            continue;
2522
2523
631
        do_subtitle_out(output_files[ost->file_index], ost, &subtitle);
2524
    }
2525
2526
676
out:
2527
685
    if (free_sub)
2528
685
        avsubtitle_free(&subtitle);
2529
685
    return ret;
2530
}
2531
2532
5780
static int send_filter_eof(InputStream *ist)
2533
{
2534
    int i, ret;
2535
    /* TODO keep pts also in stream time base to avoid converting back */
2536
5780
    int64_t pts = av_rescale_q_rnd(ist->pts, AV_TIME_BASE_Q, ist->st->time_base,
2537
                                   AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
2538
2539
11532
    for (i = 0; i < ist->nb_filters; i++) {
2540
5752
        ret = ifilter_send_eof(ist->filters[i], pts);
2541
5752
        if (ret < 0)
2542
            return ret;
2543
    }
2544
5780
    return 0;
2545
}
2546
2547
/* pkt = NULL means EOF (needed to flush decoder buffers) */
2548
413450
static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
2549
{
2550
413450
    int ret = 0, i;
2551
413450
    int repeating = 0;
2552
413450
    int eof_reached = 0;
2553
2554
    AVPacket avpkt;
2555
413450
    if (!ist->saw_first_ts) {
2556
6122
        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;
2557
6122
        ist->pts = 0;
2558

6122
        if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2559
218
            ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2560
218
            ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2561
        }
2562
6122
        ist->saw_first_ts = 1;
2563
    }
2564
2565
413450
    if (ist->next_dts == AV_NOPTS_VALUE)
2566
6536
        ist->next_dts = ist->dts;
2567
413450
    if (ist->next_pts == AV_NOPTS_VALUE)
2568
6122
        ist->next_pts = ist->pts;
2569
2570
413450
    if (!pkt) {
2571
        /* EOF handling */
2572
6518
        av_init_packet(&avpkt);
2573
6518
        avpkt.data = NULL;
2574
6518
        avpkt.size = 0;
2575
    } else {
2576
406932
        avpkt = *pkt;
2577
    }
2578
2579

413450
    if (pkt && pkt->dts != AV_NOPTS_VALUE) {
2580
370217
        ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2581

370217
        if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2582
295610
            ist->next_pts = ist->pts = ist->dts;
2583
    }
2584
2585
    // while we have more to decode or while the decoder did output something on EOF
2586
808306
    while (ist->decoding_needed) {
2587
776267
        int64_t duration_dts = 0;
2588
776267
        int64_t duration_pts = 0;
2589
776267
        int got_output = 0;
2590
776267
        int decode_failed = 0;
2591
2592
776267
        ist->pts = ist->next_pts;
2593
776267
        ist->dts = ist->next_dts;
2594
2595

776267
        switch (ist->dec_ctx->codec_type) {
2596
565764
        case AVMEDIA_TYPE_AUDIO:
2597
565764
            ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
2598
                                   &decode_failed);
2599
565764
            break;
2600
208546
        case AVMEDIA_TYPE_VIDEO:
2601
208546
            ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, &duration_pts, !pkt,
2602
                                   &decode_failed);
2603

208546
            if (!repeating || !pkt || got_output) {
2604

110057
                if (pkt && pkt->duration) {
2605
102495
                    duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2606

7562
                } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2607
6315
                    int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
2608
6315
                    duration_dts = ((int64_t)AV_TIME_BASE *
2609
6315
                                    ist->dec_ctx->framerate.den * ticks) /
2610
6315
                                    ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2611
                }
2612
2613

110057
                if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
2614
108810
                    ist->next_dts += duration_dts;
2615
                }else
2616
1247
                    ist->next_dts = AV_NOPTS_VALUE;
2617
            }
2618
2619
208546
            if (got_output) {
2620
99133
                if (duration_pts > 0) {
2621
96845
                    ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
2622
                } else {
2623
2288
                    ist->next_pts += duration_dts;
2624
                }
2625
            }
2626
208546
            break;
2627
1957
        case AVMEDIA_TYPE_SUBTITLE:
2628
1957
            if (repeating)
2629
685
                break;
2630
1272
            ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
2631

1272
            if (!pkt && ret >= 0)
2632
34
                ret = AVERROR_EOF;
2633
1272
            break;
2634
        default:
2635
            return -1;
2636
        }
2637
2638
776267
        if (ret == AVERROR_EOF) {
2639
5780
            eof_reached = 1;
2640
381411
            break;
2641
        }
2642
2643
770487
        if (ret < 0) {
2644
463
            if (decode_failed) {
2645
926
                av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2646
463
                       ist->file_index, ist->st->index, av_err2str(ret));
2647
            } else {
2648
                av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
2649
                       "data for stream #%d:%d\n", ist->file_index, ist->st->index);
2650
            }
2651

463
            if (!decode_failed || exit_on_error)
2652
                exit_program(1);
2653
463
            break;
2654
        }
2655
2656
770024
        if (got_output)
2657
395528
            ist->got_output = 1;
2658
2659
770024
        if (!got_output)
2660
374496
            break;
2661
2662
        // During draining, we might get multiple output frames in this loop.
2663
        // ffmpeg.c does not drain the filter chain on configuration changes,
2664
        // which means if we send multiple frames at once to the filters, and
2665
        // one of those frames changes configuration, the buffered frames will
2666
        // be lost. This can upset certain FATE tests.
2667
        // Decode only 1 frame per call on EOF to appease these FATE tests.
2668
        // The ideal solution would be to rewrite decoding to use the new
2669
        // decoding API in a better way.
2670
395528
        if (!pkt)
2671
672
            break;
2672
2673
394856
        repeating = 1;
2674
    }
2675
2676
    /* after flushing, send an EOF on all the filter inputs attached to the stream */
2677
    /* except when looping we need to flush but not to send an EOF */
2678


413450
    if (!pkt && ist->decoding_needed && eof_reached && !no_eof) {
2679
5780
        int ret = send_filter_eof(ist);
2680
5780
        if (ret < 0) {
2681
            av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2682
            exit_program(1);
2683
        }
2684
    }
2685
2686
    /* handle stream copy */
2687

413450
    if (!ist->decoding_needed && pkt) {
2688
31974
        ist->dts = ist->next_dts;
2689
31974
        switch (ist->dec_ctx->codec_type) {
2690
21499
        case AVMEDIA_TYPE_AUDIO:
2691
            av_assert1(pkt->duration >= 0);
2692
21499
            if (ist->dec_ctx->sample_rate) {
2693
21499
                ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2694
21499
                                  ist->dec_ctx->sample_rate;
2695
            } else {
2696
                ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2697
            }
2698
21499
            break;
2699
9944
        case AVMEDIA_TYPE_VIDEO:
2700
9944
            if (ist->framerate.num) {
2701
                // TODO: Remove work-around for c99-to-c89 issue 7
2702
79
                AVRational time_base_q = AV_TIME_BASE_Q;
2703
79
                int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2704
79
                ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2705
9865
            } else if (pkt->duration) {
2706
9462
                ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2707
403
            } else if(ist->dec_ctx->framerate.num != 0) {
2708
276
                int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2709
276
                ist->next_dts += ((int64_t)AV_TIME_BASE *
2710
276
                                  ist->dec_ctx->framerate.den * ticks) /
2711
276
                                  ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2712
            }
2713
9944
            break;
2714
        }
2715
31974
        ist->pts = ist->dts;
2716
31974
        ist->next_pts = ist->next_dts;
2717
    }
2718
840937
    for (i = 0; i < nb_output_streams; i++) {
2719
427487
        OutputStream *ost = output_streams[i];
2720
2721

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

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

5969
    if (sdp_filename || want_sdp)
2975
        print_sdp();
2976
2977
    /* flush the muxing queues */
2978
12085
    for (i = 0; i < of->ctx->nb_streams; i++) {
2979
6116
        OutputStream *ost = output_streams[of->ost_index + i];
2980
2981
        /* try to improve muxing time_base (only possible if nothing has been written yet) */
2982
6116
        if (!av_fifo_size(ost->muxing_queue))
2983
6037
            ost->mux_timebase = ost->st->time_base;
2984
2985
6407
        while (av_fifo_size(ost->muxing_queue)) {
2986
            AVPacket pkt;
2987
291
            av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
2988
291
            write_packet(of, &pkt, ost, 1);
2989
        }
2990
    }
2991
2992
5969
    return 0;
2993
}
2994
2995
6116
static int init_output_bsfs(OutputStream *ost)
2996
{
2997
6116
    AVBSFContext *ctx = ost->bsf_ctx;
2998
    int ret;
2999
3000
6116
    if (!ctx)
3001
6031
        return 0;
3002
3003
85
    ret = avcodec_parameters_copy(ctx->par_in, ost->st->codecpar);
3004
85
    if (ret < 0)
3005
        return ret;
3006
3007
85
    ctx->time_base_in = ost->st->time_base;
3008
3009
85
    ret = av_bsf_init(ctx);
3010
85
    if (ret < 0) {
3011
        av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
3012
               ctx->filter->name);
3013
        return ret;
3014
    }
3015
3016
85
    ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
3017
85
    if (ret < 0)
3018
        return ret;
3019
85
    ost->st->time_base = ctx->time_base_out;
3020
3021
85
    return 0;
3022
}
3023
3024
297
static int init_output_stream_streamcopy(OutputStream *ost)
3025
{
3026
297
    OutputFile *of = output_files[ost->file_index];
3027
297
    InputStream *ist = get_input_stream(ost);
3028
297
    AVCodecParameters *par_dst = ost->st->codecpar;
3029
297
    AVCodecParameters *par_src = ost->ref_par;
3030
    AVRational sar;
3031
    int i, ret;
3032
297
    uint32_t codec_tag = par_dst->codec_tag;
3033
3034

297
    av_assert0(ist && !ost->filter);
3035
3036
297
    ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
3037
297
    if (ret >= 0)
3038
297
        ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
3039
297
    if (ret < 0) {
3040
        av_log(NULL, AV_LOG_FATAL,
3041
               "Error setting up codec context options.\n");
3042
        return ret;
3043
    }
3044
3045
297
    ret = avcodec_parameters_from_context(par_src, ost->enc_ctx);
3046
297
    if (ret < 0) {
3047
        av_log(NULL, AV_LOG_FATAL,
3048
               "Error getting reference codec parameters.\n");
3049
        return ret;
3050
    }
3051
3052
297
    if (!codec_tag) {
3053
        unsigned int codec_tag_tmp;
3054
291
        if (!of->ctx->oformat->codec_tag ||
3055

71
            av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
3056
26
            !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag_tmp))
3057
268
            codec_tag = par_src->codec_tag;
3058
    }
3059
3060
297
    ret = avcodec_parameters_copy(par_dst, par_src);
3061
297
    if (ret < 0)
3062
        return ret;
3063
3064
297
    par_dst->codec_tag = codec_tag;
3065
3066
297
    if (!ost->frame_rate.num)
3067
296
        ost->frame_rate = ist->framerate;
3068
297
    ost->st->avg_frame_rate = ost->frame_rate;
3069
3070
297
    ret = avformat_transfer_internal_stream_timing_info(of->ctx->oformat, ost->st, ist->st, copy_tb);
3071
297
    if (ret < 0)
3072
        return ret;
3073
3074
    // copy timebase while removing common factors
3075

297
    if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3076
296
        ost->st->time_base = av_add_q(av_stream_get_codec_timebase(ost->st), (AVRational){0, 1});
3077
3078
    // copy estimated duration as a hint to the muxer
3079

297
    if (ost->st->duration <= 0 && ist->st->duration > 0)
3080
174
        ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3081
3082
    // copy disposition
3083
297
    ost->st->disposition = ist->st->disposition;
3084
3085
297
    if (ist->st->nb_side_data) {
3086
46
        for (i = 0; i < ist->st->nb_side_data; i++) {
3087
23
            const AVPacketSideData *sd_src = &ist->st->side_data[i];
3088
            uint8_t *dst_data;
3089
3090
23
            dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3091
23
            if (!dst_data)
3092
                return AVERROR(ENOMEM);
3093
23
            memcpy(dst_data, sd_src->data, sd_src->size);
3094
        }
3095
    }
3096
3097
297
    if (ost->rotate_overridden) {
3098
1
        uint8_t *sd = av_stream_new_side_data(ost->st, AV_PKT_DATA_DISPLAYMATRIX,
3099
                                              sizeof(int32_t) * 9);
3100
1
        if (sd)
3101
1
            av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
3102
    }
3103
3104
297
    switch (par_dst->codec_type) {
3105
109
    case AVMEDIA_TYPE_AUDIO:
3106
109
        if (audio_volume != 256) {
3107
            av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3108
            exit_program(1);
3109
        }
3110


109
        if((par_dst->block_align == 1 || par_dst->block_align == 1152 || par_dst->block_align == 576) && par_dst->codec_id == AV_CODEC_ID_MP3)
3111
            par_dst->block_align= 0;
3112
109
        if(par_dst->codec_id == AV_CODEC_ID_AC3)
3113
3
            par_dst->block_align= 0;
3114
109
        break;
3115
171
    case AVMEDIA_TYPE_VIDEO:
3116
171
        if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
3117
            sar =
3118
                av_mul_q(ost->frame_aspect_ratio,
3119
                         (AVRational){ par_dst->height, par_dst->width });
3120
            av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
3121
                   "with stream copy may produce invalid files\n");
3122
            }
3123
171
        else if (ist->st->sample_aspect_ratio.num)
3124
56
            sar = ist->st->sample_aspect_ratio;
3125
        else
3126
115
            sar = par_src->sample_aspect_ratio;
3127
171
        ost->st->sample_aspect_ratio = par_dst->sample_aspect_ratio = sar;
3128
171
        ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3129
171
        ost->st->r_frame_rate = ist->st->r_frame_rate;
3130
171
        break;
3131
    }
3132
3133
297
    ost->mux_timebase = ist->st->time_base;
3134
3135
297
    return 0;
3136
}
3137
3138
5818
static void set_encoder_id(OutputFile *of, OutputStream *ost)
3139
{
3140
    AVDictionaryEntry *e;
3141
3142
    uint8_t *encoder_string;
3143
    int encoder_string_len;
3144
5818
    int format_flags = 0;
3145
5818
    int codec_flags = ost->enc_ctx->flags;
3146
3147
5818
    if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
3148
        return;
3149
3150
5818
    e = av_dict_get(of->opts, "fflags", NULL, 0);
3151
5818
    if (e) {
3152
3385
        const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
3153
3385
        if (!o)
3154
            return;
3155
3385
        av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
3156
    }
3157
5818
    e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
3158
5818
    if (e) {
3159
3383
        const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
3160
3383
        if (!o)
3161
            return;
3162
3383
        av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
3163
    }
3164
3165
5818
    encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
3166
5818
    encoder_string     = av_mallocz(encoder_string_len);
3167
5818
    if (!encoder_string)
3168
        exit_program(1);
3169
3170

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

66
            if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
3291
                break;
3292
        }
3293
60
        if (j == oc->nb_streams)
3294
60
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
3295
51
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3296
60
                ost->st->disposition = AV_DISPOSITION_DEFAULT;
3297
    }
3298
3299
5818
    if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3300
4669
        if (!ost->frame_rate.num)
3301
4649
            ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3302

4669
        if (ist && !ost->frame_rate.num)
3303
2
            ost->frame_rate = ist->framerate;
3304

4669
        if (ist && !ost->frame_rate.num)
3305
2
            ost->frame_rate = ist->st->r_frame_rate;
3306

4669
        if (ist && !ost->frame_rate.num) {
3307
2
            ost->frame_rate = (AVRational){25, 1};
3308
2
            av_log(NULL, AV_LOG_WARNING,
3309
                   "No information "
3310
                   "about the input framerate is available. Falling "
3311
                   "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3312
                   "if you want a different framerate.\n",
3313
                   ost->file_index, ost->index);
3314
        }
3315
3316

4669
        if (ost->enc->supported_framerates && !ost->force_fps) {
3317
48
            int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3318
48
            ost->frame_rate = ost->enc->supported_framerates[idx];
3319
        }
3320
        // reduce frame rate for mpeg4 to be within the spec limits
3321
4669
        if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3322
58
            av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3323
58
                      ost->frame_rate.num, ost->frame_rate.den, 65535);
3324
        }
3325
    }
3326
3327

5818
    switch (enc_ctx->codec_type) {
3328
1118
    case AVMEDIA_TYPE_AUDIO:
3329
1118
        enc_ctx->sample_fmt     = av_buffersink_get_format(ost->filter->filter);
3330
1118
        if (dec_ctx)
3331
1109
            enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
3332
                                                 av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
3333
1118
        enc_ctx->sample_rate    = av_buffersink_get_sample_rate(ost->filter->filter);
3334
1118
        enc_ctx->channel_layout = av_buffersink_get_channel_layout(ost->filter->filter);
3335
1118
        enc_ctx->channels       = av_buffersink_get_channels(ost->filter->filter);
3336
3337
1118
        init_encoder_time_base(ost, av_make_q(1, enc_ctx->sample_rate));
3338
1118
        break;
3339
3340
4669
    case AVMEDIA_TYPE_VIDEO:
3341
4669
        init_encoder_time_base(ost, av_inv_q(ost->frame_rate));
3342
3343

4669
        if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
3344
1
            enc_ctx->time_base = av_buffersink_get_time_base(ost->filter->filter);
3345

4669
        if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3346


4
           && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3347
            av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3348
                                       "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3349