GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg.c Lines: 2033 2750 73.9 %
Date: 2020-07-11 02:49:52 Branches: 1491 2149 69.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
209
void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub)
241
{
242
209
    AVFrame *frame = ist->sub2video.frame;
243
    int8_t *dst;
244
    int     dst_linesize;
245
    int num_rects, i;
246
    int64_t pts, end_pts;
247
248
209
    if (!frame)
249
29
        return;
250
180
    if (sub) {
251
88
        pts       = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
252
88
                                 AV_TIME_BASE_Q, ist->st->time_base);
253
88
        end_pts   = av_rescale_q(sub->pts + sub->end_display_time   * 1000LL,
254
88
                                 AV_TIME_BASE_Q, ist->st->time_base);
255
88
        num_rects = sub->num_rects;
256
    } else {
257
        /* If we are initializing the system, utilize current heartbeat
258
           PTS as the start time, and show until the following subpicture
259
           is received. Otherwise, utilize the previous subpicture's end time
260
           as the fall-back value. */
261
184
        pts       = ist->sub2video.initialize ?
262
92
                    heartbeat_pts : ist->sub2video.end_pts;
263
92
        end_pts   = INT64_MAX;
264
92
        num_rects = 0;
265
    }
266
180
    if (sub2video_get_blank_frame(ist) < 0) {
267
        av_log(ist->dec_ctx, AV_LOG_ERROR,
268
               "Impossible to get a blank canvas.\n");
269
        return;
270
    }
271
180
    dst          = frame->data    [0];
272
180
    dst_linesize = frame->linesize[0];
273
269
    for (i = 0; i < num_rects; i++)
274
89
        sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
275
180
    sub2video_push_ref(ist, pts);
276
180
    ist->sub2video.end_pts = end_pts;
277
180
    ist->sub2video.initialize = 0;
278
}
279
280
427234
static void sub2video_heartbeat(InputStream *ist, int64_t pts)
281
{
282
427234
    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
893330
    for (i = 0; i < infile->nb_streams; i++) {
291
466096
        InputStream *ist2 = input_streams[infile->ist_index + i];
292
466096
        if (!ist2->sub2video.frame)
293
465151
            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
427234
}
311
312
33
static void sub2video_flush(InputStream *ist)
313
{
314
    int i;
315
    int ret;
316
317
33
    if (ist->sub2video.end_pts < INT64_MAX)
318
33
        sub2video_update(ist, INT64_MAX, NULL);
319
37
    for (i = 0; i < ist->nb_filters; i++) {
320
4
        ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
321

4
        if (ret != AVERROR_EOF && ret < 0)
322
            av_log(NULL, AV_LOG_WARNING, "Flush the frame error.\n");
323
    }
324
33
}
325
326
/* end of sub2video hack */
327
328
11912
static void term_exit_sigsafe(void)
329
{
330
#if HAVE_TERMIOS_H
331
11912
    if(restore_tty)
332
2
        tcsetattr (0, TCSANOW, &oldtty);
333
#endif
334
11912
}
335
336
11912
void term_exit(void)
337
{
338
11912
    av_log(NULL, AV_LOG_QUIET, "%s", "");
339
11912
    term_exit_sigsafe();
340
11912
}
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
5956
void term_init(void)
396
{
397
#if HAVE_TERMIOS_H
398

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

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

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

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

454960
    if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
748

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

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

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

192249
        if ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO || st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) &&
788
192236
            pkt->dts != AV_NOPTS_VALUE &&
789

168908
            !(st->codecpar->codec_id == AV_CODEC_ID_VP9 && ost->stream_copy) &&
790
168675
            ost->last_mux_dts != AV_NOPTS_VALUE) {
791
164178
            int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
792
164178
            if (pkt->dts < max) {
793

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

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

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

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

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

101800
    if (frame_rate.num > 0 && frame_rate.den > 0)
1064
101671
        duration = 1/(av_q2d(frame_rate) * av_q2d(enc->time_base));
1065
1066


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

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

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

56363
            if (format_video_sync == VSYNC_CFR && copy_ts) {
1104
                format_video_sync = VSYNC_VSCFR;
1105
            }
1106
        }
1107

99390
        ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
1108
1109

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

99390
        switch (format_video_sync) {
1123
8349
        case VSYNC_VSCFR:
1124

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

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

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

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

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

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

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

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

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

99428
        if (vstats_filename && frame_size)
1327
            do_video_stats(ost, frame_size);
1328
    }
1329
1330
101799
    if (!ost->last_frame)
1331
4741
        ost->last_frame = av_frame_alloc();
1332
101799
    av_frame_unref(ost->last_frame);
1333

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

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

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

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

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

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

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

1003638
    if (!print_stats && !is_last_report && !progress_avio)
1653
997656
        return;
1654
1655
16318
    if (!is_last_report) {
1656
10363
        if (last_time == -1) {
1657
32
            last_time = cur_time;
1658
32
            return;
1659
        }
1660
10331
        if ((cur_time - last_time) < 500000)
1661
10304
            return;
1662
27
        last_time = cur_time;
1663
    }
1664
1665
5982
    t = (cur_time-timer_start) / 1000000.0;
1666
1667
1668
5982
    oc = output_files[0]->ctx;
1669
1670
5982
    total_size = avio_size(oc->pb);
1671
5982
    if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1672
80
        total_size = avio_tell(oc->pb);
1673
1674
5982
    vid = 0;
1675
5982
    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
1676
5982
    av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
1677
12112
    for (i = 0; i < nb_output_streams; i++) {
1678
6130
        float q = -1;
1679
6130
        ost = output_streams[i];
1680
6130
        enc = ost->enc_ctx;
1681
6130
        if (!ost->stream_copy)
1682
5833
            q = ost->quality / (float) FF_QP2LAMBDA;
1683
1684

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

809029
    if (*got_output || ret<0)
2079
416383
        decode_error_stat[ret<0] ++;
2080
2081

809029
    if (ret < 0 && exit_on_error)
2082
        exit_program(1);
2083
2084

809029
    if (*got_output && ist) {
2085

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

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

631997
                       ifilter->channels       != frame->channels ||
2118
315440
                       ifilter->channel_layout != frame->channel_layout;
2119
316557
        break;
2120
99123
    case AVMEDIA_TYPE_VIDEO:
2121
193591
        need_reinit |= ifilter->width  != frame->width ||
2122
94468
                       ifilter->height != frame->height;
2123
99123
        break;
2124
    }
2125
2126

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

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

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

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

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

398928
        if (ret < 0 && ret != AVERROR_EOF)
2221
379
            return ret;
2222
    }
2223
2224
813157
    ret = avcodec_receive_frame(avctx, frame);
2225

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

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

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

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

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

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

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

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

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

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

206882
    if (!*got_output || ret < 0)
2397
107759
        return ret;
2398
2399
99123
    if(ist->top_field_first>=0)
2400
        decoded_frame->top_field_first = ist->top_field_first;
2401
2402
99123
    ist->frames_decoded++;
2403
2404

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

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

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

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

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

433737
    if (pkt && pkt->dts != AV_NOPTS_VALUE) {
2579
390519
        ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2580

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

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

208427
            if (!repeating || !pkt || got_output) {
2603

109948
                if (pkt && pkt->duration) {
2604
102396
                    duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2605

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

109948
                if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
2613
108711
                    ist->next_dts += duration_dts;
2614
                }else
2615
1237
                    ist->next_dts = AV_NOPTS_VALUE;
2616
            }
2617
2618
208427
            if (got_output) {
2619
99123
                if (duration_pts > 0) {
2620
96835
                    ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
2621
                } else {
2622
2288
                    ist->next_pts += duration_dts;
2623
                }
2624
            }
2625
208427
            break;
2626
1865
        case AVMEDIA_TYPE_SUBTITLE:
2627
1865
            if (repeating)
2628
640
                break;
2629
1225
            ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
2630

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

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


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

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

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

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

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

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

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

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

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


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

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

68
            if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
3290
                break;
3291
        }
3292
62
        if (j == oc->nb_streams)
3293
62
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
3294
53
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3295
62
                ost->st->disposition = AV_DISPOSITION_DEFAULT;
3296
    }
3297
3298
5805
    if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3299
4661
        if (!ost->frame_rate.num)
3300
4641
            ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3301

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

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

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

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

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

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

4661
        if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3345


4
           && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3346
            av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3347
                                       "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3348
        }
3349
3350
4661
        enc_ctx->width  = av_buffersink_get_w(ost->filter->filter);
3351
4661
        enc_ctx->height = av_buffersink_get_h(ost->filter->filter);
3352
9322
        enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =