GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg.c Lines: 2021 2764 73.1 %
Date: 2020-01-29 01:05:39 Branches: 1479 2161 68.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
90
static int sub2video_get_blank_frame(InputStream *ist)
177
{
178
    int ret;
179
90
    AVFrame *frame = ist->sub2video.frame;
180
181
90
    av_frame_unref(frame);
182
90
    ist->sub2video.frame->width  = ist->dec_ctx->width  ? ist->dec_ctx->width  : ist->sub2video.w;
183
90
    ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
184
90
    ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
185
90
    if ((ret = av_frame_get_buffer(frame, 32)) < 0)
186
        return ret;
187
90
    memset(frame->data[0], 0, frame->height * frame->linesize[0]);
188
90
    return 0;
189
}
190
191
44
static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
192
                                AVSubtitleRect *r)
193
{
194
    uint32_t *pal, *dst2;
195
    uint8_t *src, *src2;
196
    int x, y;
197
198
44
    if (r->type != SUBTITLE_BITMAP) {
199
        av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
200
        return;
201
    }
202


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

99059
        if (vstats_filename && frame_size)
1339
            do_video_stats(ost, frame_size);
1340
    }
1341
1342
101428
    if (!ost->last_frame)
1343
4674
        ost->last_frame = av_frame_alloc();
1344
101428
    av_frame_unref(ost->last_frame);
1345

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

30752
    if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2012
12
        !ost->copy_initial_nonkeyframes)
2013
12
        return;
2014
2015

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

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

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

763689
    if (*got_output || ret<0)
2094
393624
        decode_error_stat[ret<0] ++;
2095
2096

763689
    if (ret < 0 && exit_on_error)
2097
        exit_program(1);
2098
2099

763689
    if (*got_output && ist) {
2100

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

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

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

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

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

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

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

376279
        if (ret < 0 && ret != AVERROR_EOF)
2236
379
            return ret;
2237
    }
2238
2239
767792
    ret = avcodec_receive_frame(avctx, frame);
2240

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

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

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

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

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

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

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

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

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

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

206448
    if (!*got_output || ret < 0)
2412
107585
        return ret;
2413
2414
98863
    if(ist->top_field_first>=0)
2415
        decoded_frame->top_field_first = ist->top_field_first;
2416
2417
98863
    ist->frames_decoded++;
2418
2419

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

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

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

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

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

409830
    if (pkt && pkt->dts != AV_NOPTS_VALUE) {
2594
366697
        ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2595

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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