GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg_opt.c Lines: 1145 1991 57.5 %
Date: 2020-01-27 20:17:04 Branches: 808 1692 47.8 %

Line Branch Exec Source
1
2
/*
3
 * ffmpeg option parsing
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
#include <stdint.h>
23
24
#include "ffmpeg.h"
25
#include "cmdutils.h"
26
27
#include "libavformat/avformat.h"
28
29
#include "libavcodec/avcodec.h"
30
31
#include "libavfilter/avfilter.h"
32
33
#include "libavutil/avassert.h"
34
#include "libavutil/avstring.h"
35
#include "libavutil/avutil.h"
36
#include "libavutil/channel_layout.h"
37
#include "libavutil/intreadwrite.h"
38
#include "libavutil/fifo.h"
39
#include "libavutil/mathematics.h"
40
#include "libavutil/opt.h"
41
#include "libavutil/parseutils.h"
42
#include "libavutil/pixdesc.h"
43
#include "libavutil/pixfmt.h"
44
45
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46
47
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48
{\
49
    int i, ret;\
50
    for (i = 0; i < o->nb_ ## name; i++) {\
51
        char *spec = o->name[i].specifier;\
52
        if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
53
            outvar = o->name[i].u.type;\
54
        else if (ret < 0)\
55
            exit_program(1);\
56
    }\
57
}
58
59
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60
{\
61
    int i;\
62
    for (i = 0; i < o->nb_ ## name; i++) {\
63
        char *spec = o->name[i].specifier;\
64
        if (!strcmp(spec, mediatype))\
65
            outvar = o->name[i].u.type;\
66
    }\
67
}
68
69
const HWAccel hwaccels[] = {
70
#if CONFIG_VIDEOTOOLBOX
71
    { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
72
#endif
73
#if CONFIG_LIBMFX
74
    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
75
#endif
76
#if CONFIG_CUVID
77
    { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
78
#endif
79
    { 0 },
80
};
81
AVBufferRef *hw_device_ctx;
82
HWDevice *filter_hw_device;
83
84
char *vstats_filename;
85
char *sdp_filename;
86
87
float audio_drift_threshold = 0.1;
88
float dts_delta_threshold   = 10;
89
float dts_error_threshold   = 3600*30;
90
91
int audio_volume      = 256;
92
int audio_sync_method = 0;
93
int video_sync_method = VSYNC_AUTO;
94
float frame_drop_threshold = 0;
95
int do_deinterlace    = 0;
96
int do_benchmark      = 0;
97
int do_benchmark_all  = 0;
98
int do_hex_dump       = 0;
99
int do_pkt_dump       = 0;
100
int copy_ts           = 0;
101
int start_at_zero     = 0;
102
int copy_tb           = -1;
103
int debug_ts          = 0;
104
int exit_on_error     = 0;
105
int abort_on_flags    = 0;
106
int print_stats       = -1;
107
int qp_hist           = 0;
108
int stdin_interaction = 1;
109
int frame_bits_per_raw_sample = 0;
110
float max_error_rate  = 2.0/3;
111
int filter_nbthreads = 0;
112
int filter_complex_nbthreads = 0;
113
int vstats_version = 2;
114
115
116
static int intra_only         = 0;
117
static int file_overwrite     = 0;
118
static int no_file_overwrite  = 0;
119
static int do_psnr            = 0;
120
static int input_sync;
121
static int input_stream_potentially_available = 0;
122
static int ignore_unknown_streams = 0;
123
static int copy_unknown_streams = 0;
124
static int find_stream_info = 1;
125
126
11755
static void uninit_options(OptionsContext *o)
127
{
128
11755
    const OptionDef *po = options;
129
    int i;
130
131
    /* all OPT_SPEC and OPT_STRING can be freed in generic way */
132
2092390
    while (po->name) {
133
2080635
        void *dst = (uint8_t*)o + po->u.off;
134
135
2080635
        if (po->flags & OPT_SPEC) {
136
540730
            SpecifierOpt **so = dst;
137
540730
            int i, *count = (int*)(so + 1);
138
564291
            for (i = 0; i < *count; i++) {
139
23561
                av_freep(&(*so)[i].specifier);
140
23561
                if (po->flags & OPT_STRING)
141
19033
                    av_freep(&(*so)[i].u.str);
142
            }
143
540730
            av_freep(so);
144
540730
            *count = 0;
145

1539905
        } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
146
11755
            av_freep(dst);
147
2080635
        po++;
148
    }
149
150
11824
    for (i = 0; i < o->nb_stream_maps; i++)
151
69
        av_freep(&o->stream_maps[i].linklabel);
152
11755
    av_freep(&o->stream_maps);
153
11755
    av_freep(&o->audio_channel_maps);
154
11755
    av_freep(&o->streamid_map);
155
11755
    av_freep(&o->attachments);
156
11755
}
157
158
11756
static void init_options(OptionsContext *o)
159
{
160
11756
    memset(o, 0, sizeof(*o));
161
162
11756
    o->stop_time = INT64_MAX;
163
11756
    o->mux_max_delay  = 0.7;
164
11756
    o->start_time     = AV_NOPTS_VALUE;
165
11756
    o->start_time_eof = AV_NOPTS_VALUE;
166
11756
    o->recording_time = INT64_MAX;
167
11756
    o->limit_filesize = UINT64_MAX;
168
11756
    o->chapters_input_file = INT_MAX;
169
11756
    o->accurate_seek  = 1;
170
11756
}
171
172
static int show_hwaccels(void *optctx, const char *opt, const char *arg)
173
{
174
    enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
175
    int i;
176
177
    printf("Hardware acceleration methods:\n");
178
    while ((type = av_hwdevice_iterate_types(type)) !=
179
           AV_HWDEVICE_TYPE_NONE)
180
        printf("%s\n", av_hwdevice_get_type_name(type));
181
    for (i = 0; hwaccels[i].name; i++)
182
        printf("%s\n", hwaccels[i].name);
183
    printf("\n");
184
    return 0;
185
}
186
187
/* return a copy of the input with the stream specifiers removed from the keys */
188
11755
static AVDictionary *strip_specifiers(AVDictionary *dict)
189
{
190
11755
    AVDictionaryEntry *e = NULL;
191
11755
    AVDictionary    *ret = NULL;
192
193
44201
    while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
194
32446
        char *p = strchr(e->key, ':');
195
196
32446
        if (p)
197
195
            *p = 0;
198
32446
        av_dict_set(&ret, e->key, e->value, 0);
199
32446
        if (p)
200
195
            *p = ':';
201
    }
202
11755
    return ret;
203
}
204
205
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
206
{
207
    static const AVOption opts[] = {
208
        { "abort_on"        , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
209
        { "empty_output"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT     },    .unit = "flags" },
210
        { NULL },
211
    };
212
    static const AVClass class = {
213
        .class_name = "",
214
        .item_name  = av_default_item_name,
215
        .option     = opts,
216
        .version    = LIBAVUTIL_VERSION_INT,
217
    };
218
    const AVClass *pclass = &class;
219
220
    return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
221
}
222
223
static int opt_sameq(void *optctx, const char *opt, const char *arg)
224
{
225
    av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
226
           "If you are looking for an option to preserve the quality (which is not "
227
           "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
228
           opt, opt);
229
    return AVERROR(EINVAL);
230
}
231
232
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
233
{
234
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
235
    return opt_default(optctx, "channel", arg);
236
}
237
238
static int opt_video_standard(void *optctx, const char *opt, const char *arg)
239
{
240
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
241
    return opt_default(optctx, "standard", arg);
242
}
243
244
14
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
245
{
246
14
    OptionsContext *o = optctx;
247
14
    return parse_option(o, "codec:a", arg, options);
248
}
249
250
4071
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
251
{
252
4071
    OptionsContext *o = optctx;
253
4071
    return parse_option(o, "codec:v", arg, options);
254
}
255
256
2
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
257
{
258
2
    OptionsContext *o = optctx;
259
2
    return parse_option(o, "codec:s", arg, options);
260
}
261
262
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
263
{
264
    OptionsContext *o = optctx;
265
    return parse_option(o, "codec:d", arg, options);
266
}
267
268
59
static int opt_map(void *optctx, const char *opt, const char *arg)
269
{
270
59
    OptionsContext *o = optctx;
271
59
    StreamMap *m = NULL;
272
59
    int i, negative = 0, file_idx, disabled = 0;
273
59
    int sync_file_idx = -1, sync_stream_idx = 0;
274
    char *p, *sync;
275
    char *map;
276
    char *allow_unused;
277
278
59
    if (*arg == '-') {
279
        negative = 1;
280
        arg++;
281
    }
282
59
    map = av_strdup(arg);
283
59
    if (!map)
284
        return AVERROR(ENOMEM);
285
286
    /* parse sync stream first, just pick first matching stream */
287
59
    if (sync = strchr(map, ',')) {
288
        *sync = 0;
289
        sync_file_idx = strtol(sync + 1, &sync, 0);
290
        if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
291
            av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
292
            exit_program(1);
293
        }
294
        if (*sync)
295
            sync++;
296
        for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
297
            if (check_stream_specifier(input_files[sync_file_idx]->ctx,
298
                                       input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
299
                sync_stream_idx = i;
300
                break;
301
            }
302
        if (i == input_files[sync_file_idx]->nb_streams) {
303
            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
304
                                       "match any streams.\n", arg);
305
            exit_program(1);
306
        }
307
        if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
308
            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
309
                                       "stream.\n", arg);
310
            exit_program(1);
311
        }
312
    }
313
314
315
59
    if (map[0] == '[') {
316
        /* this mapping refers to lavfi output */
317
3
        const char *c = map + 1;
318
3
        GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
319
3
        m = &o->stream_maps[o->nb_stream_maps - 1];
320
3
        m->linklabel = av_get_token(&c, "]");
321
3
        if (!m->linklabel) {
322
            av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
323
            exit_program(1);
324
        }
325
    } else {
326
56
        if (allow_unused = strchr(map, '?'))
327
            *allow_unused = 0;
328
56
        file_idx = strtol(map, &p, 0);
329

56
        if (file_idx >= nb_input_files || file_idx < 0) {
330
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
331
            exit_program(1);
332
        }
333
56
        if (negative)
334
            /* disable some already defined maps */
335
            for (i = 0; i < o->nb_stream_maps; i++) {
336
                m = &o->stream_maps[i];
337
                if (file_idx == m->file_index &&
338
                    check_stream_specifier(input_files[m->file_index]->ctx,
339
                                           input_files[m->file_index]->ctx->streams[m->stream_index],
340
                                           *p == ':' ? p + 1 : p) > 0)
341
                    m->disabled = 1;
342
            }
343
        else
344
156
            for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
345
100
                if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
346
100
                            *p == ':' ? p + 1 : p) <= 0)
347
34
                    continue;
348
66
                if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
349
                    disabled = 1;
350
                    continue;
351
                }
352
66
                GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
353
66
                m = &o->stream_maps[o->nb_stream_maps - 1];
354
355
66
                m->file_index   = file_idx;
356
66
                m->stream_index = i;
357
358
66
                if (sync_file_idx >= 0) {
359
                    m->sync_file_index   = sync_file_idx;
360
                    m->sync_stream_index = sync_stream_idx;
361
                } else {
362
66
                    m->sync_file_index   = file_idx;
363
66
                    m->sync_stream_index = i;
364
                }
365
            }
366
    }
367
368
59
    if (!m) {
369
        if (allow_unused) {
370
            av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
371
        } else if (disabled) {
372
            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
373
                                       "To ignore this, add a trailing '?' to the map.\n", arg);
374
            exit_program(1);
375
        } else {
376
            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
377
                                       "To ignore this, add a trailing '?' to the map.\n", arg);
378
            exit_program(1);
379
        }
380
    }
381
382
59
    av_freep(&map);
383
59
    return 0;
384
}
385
386
1
static int opt_attach(void *optctx, const char *opt, const char *arg)
387
{
388
1
    OptionsContext *o = optctx;
389
1
    GROW_ARRAY(o->attachments, o->nb_attachments);
390
1
    o->attachments[o->nb_attachments - 1] = arg;
391
1
    return 0;
392
}
393
394
10
static int opt_map_channel(void *optctx, const char *opt, const char *arg)
395
{
396
10
    OptionsContext *o = optctx;
397
    int n;
398
    AVStream *st;
399
    AudioChannelMap *m;
400
    char *allow_unused;
401
    char *mapchan;
402
10
    mapchan = av_strdup(arg);
403
10
    if (!mapchan)
404
        return AVERROR(ENOMEM);
405
406
10
    GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
407
10
    m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
408
409
    /* muted channel syntax */
410
10
    n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
411

10
    if ((n == 1 || n == 3) && m->channel_idx == -1) {
412
1
        m->file_idx = m->stream_idx = -1;
413
1
        if (n == 1)
414
1
            m->ofile_idx = m->ostream_idx = -1;
415
1
        av_free(mapchan);
416
1
        return 0;
417
    }
418
419
    /* normal syntax */
420
9
    n = sscanf(arg, "%d.%d.%d:%d.%d",
421
               &m->file_idx,  &m->stream_idx, &m->channel_idx,
422
               &m->ofile_idx, &m->ostream_idx);
423
424

9
    if (n != 3 && n != 5) {
425
        av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
426
               "[file.stream.channel|-1][:syncfile:syncstream]\n");
427
        exit_program(1);
428
    }
429
430
9
    if (n != 5) // only file.stream.channel specified
431
9
        m->ofile_idx = m->ostream_idx = -1;
432
433
    /* check input */
434

9
    if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
435
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
436
               m->file_idx);
437
        exit_program(1);
438
    }
439
9
    if (m->stream_idx < 0 ||
440
9
        m->stream_idx >= input_files[m->file_idx]->nb_streams) {
441
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
442
               m->file_idx, m->stream_idx);
443
        exit_program(1);
444
    }
445
9
    st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
446
9
    if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
447
        av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
448
               m->file_idx, m->stream_idx);
449
        exit_program(1);
450
    }
451
    /* allow trailing ? to map_channel */
452
9
    if (allow_unused = strchr(mapchan, '?'))
453
2
        *allow_unused = 0;
454

9
    if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
455
8
        input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
456
1
        if (allow_unused) {
457
1
            av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
458
                    m->file_idx, m->stream_idx, m->channel_idx);
459
        } else {
460
            av_log(NULL, AV_LOG_FATAL,  "mapchan: invalid audio channel #%d.%d.%d\n"
461
                    "To ignore this, add a trailing '?' to the map_channel.\n",
462
                    m->file_idx, m->stream_idx, m->channel_idx);
463
            exit_program(1);
464
        }
465
466
    }
467
9
    av_free(mapchan);
468
9
    return 0;
469
}
470
471
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
472
{
473
    av_free(sdp_filename);
474
    sdp_filename = av_strdup(arg);
475
    return 0;
476
}
477
478
#if CONFIG_VAAPI
479
static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
480
{
481
    HWDevice *dev;
482
    const char *prefix = "vaapi:";
483
    char *tmp;
484
    int err;
485
    tmp = av_asprintf("%s%s", prefix, arg);
486
    if (!tmp)
487
        return AVERROR(ENOMEM);
488
    err = hw_device_init_from_string(tmp, &dev);
489
    av_free(tmp);
490
    if (err < 0)
491
        return err;
492
    hw_device_ctx = av_buffer_ref(dev->device_ref);
493
    if (!hw_device_ctx)
494
        return AVERROR(ENOMEM);
495
    return 0;
496
}
497
#endif
498
499
static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
500
{
501
    if (!strcmp(arg, "list")) {
502
        enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
503
        printf("Supported hardware device types:\n");
504
        while ((type = av_hwdevice_iterate_types(type)) !=
505
               AV_HWDEVICE_TYPE_NONE)
506
            printf("%s\n", av_hwdevice_get_type_name(type));
507
        printf("\n");
508
        exit_program(0);
509
    } else {
510
        return hw_device_init_from_string(arg, NULL);
511
    }
512
}
513
514
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
515
{
516
    if (filter_hw_device) {
517
        av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
518
        return AVERROR(EINVAL);
519
    }
520
    filter_hw_device = hw_device_get_by_name(arg);
521
    if (!filter_hw_device) {
522
        av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
523
        return AVERROR(EINVAL);
524
    }
525
    return 0;
526
}
527
528
/**
529
 * Parse a metadata specifier passed as 'arg' parameter.
530
 * @param arg  metadata string to parse
531
 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
532
 * @param index for type c/p, chapter/program index is written here
533
 * @param stream_spec for type s, the stream specifier is written here
534
 */
535
152
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
536
{
537
152
    if (*arg) {
538
29
        *type = *arg;
539

29
        switch (*arg) {
540
17
        case 'g':
541
17
            break;
542
12
        case 's':
543

12
            if (*(++arg) && *arg != ':') {
544
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
545
                exit_program(1);
546
            }
547
12
            *stream_spec = *arg == ':' ? arg + 1 : "";
548
12
            break;
549
        case 'c':
550
        case 'p':
551
            if (*(++arg) == ':')
552
                *index = strtol(++arg, NULL, 0);
553
            break;
554
        default:
555
            av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
556
            exit_program(1);
557
        }
558
    } else
559
123
        *type = 'g';
560
152
}
561
562
5
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
563
{
564
5
    AVDictionary **meta_in = NULL;
565
5
    AVDictionary **meta_out = NULL;
566
5
    int i, ret = 0;
567
    char type_in, type_out;
568
5
    const char *istream_spec = NULL, *ostream_spec = NULL;
569
5
    int idx_in = 0, idx_out = 0;
570
571
5
    parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
572
5
    parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
573
574
5
    if (!ic) {
575

2
        if (type_out == 'g' || !*outspec)
576
2
            o->metadata_global_manual = 1;
577

2
        if (type_out == 's' || !*outspec)
578
            o->metadata_streams_manual = 1;
579

2
        if (type_out == 'c' || !*outspec)
580
            o->metadata_chapters_manual = 1;
581
2
        return 0;
582
    }
583
584

3
    if (type_in == 'g' || type_out == 'g')
585
1
        o->metadata_global_manual = 1;
586

3
    if (type_in == 's' || type_out == 's')
587
2
        o->metadata_streams_manual = 1;
588

3
    if (type_in == 'c' || type_out == 'c')
589
        o->metadata_chapters_manual = 1;
590
591
    /* ic is NULL when just disabling automatic mappings */
592
3
    if (!ic)
593
        return 0;
594
595
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
596
    if ((index) < 0 || (index) >= (nb_elems)) {\
597
        av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
598
                (desc), (index));\
599
        exit_program(1);\
600
    }
601
602
#define SET_DICT(type, meta, context, index)\
603
        switch (type) {\
604
        case 'g':\
605
            meta = &context->metadata;\
606
            break;\
607
        case 'c':\
608
            METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
609
            meta = &context->chapters[index]->metadata;\
610
            break;\
611
        case 'p':\
612
            METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
613
            meta = &context->programs[index]->metadata;\
614
            break;\
615
        case 's':\
616
            break; /* handled separately below */ \
617
        default: av_assert0(0);\
618
        }\
619
620



3
    SET_DICT(type_in, meta_in, ic, idx_in);
621



3
    SET_DICT(type_out, meta_out, oc, idx_out);
622
623
    /* for input streams choose first matching stream */
624
3
    if (type_in == 's') {
625
3
        for (i = 0; i < ic->nb_streams; i++) {
626
3
            if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
627
2
                meta_in = &ic->streams[i]->metadata;
628
2
                break;
629
1
            } else if (ret < 0)
630
                exit_program(1);
631
        }
632
2
        if (!meta_in) {
633
            av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
634
            exit_program(1);
635
        }
636
    }
637
638
3
    if (type_out == 's') {
639
8
        for (i = 0; i < oc->nb_streams; i++) {
640
6
            if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
641
2
                meta_out = &oc->streams[i]->metadata;
642
2
                av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
643
4
            } else if (ret < 0)
644
                exit_program(1);
645
        }
646
    } else
647
1
        av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
648
649
3
    return 0;
650
}
651
652
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
653
{
654
    OptionsContext *o = optctx;
655
    char buf[128];
656
    int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
657
    struct tm time = *gmtime((time_t*)&recording_timestamp);
658
    if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
659
        return -1;
660
    parse_option(o, "metadata", buf, options);
661
662
    av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
663
                                 "tag instead.\n", opt);
664
    return 0;
665
}
666
667
10022
static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
668
{
669
    const AVCodecDescriptor *desc;
670
10022
    const char *codec_string = encoder ? "encoder" : "decoder";
671
    AVCodec *codec;
672
673
10022
    codec = encoder ?
674
10022
        avcodec_find_encoder_by_name(name) :
675
6916
        avcodec_find_decoder_by_name(name);
676
677

10022
    if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
678
1
        codec = encoder ? avcodec_find_encoder(desc->id) :
679
                          avcodec_find_decoder(desc->id);
680
1
        if (codec)
681
1
            av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
682
                   codec_string, codec->name, desc->name);
683
    }
684
685
10022
    if (!codec) {
686
        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
687
        exit_program(1);
688
    }
689
10022
    if (codec->type != type) {
690
        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
691
        exit_program(1);
692
    }
693
10022
    return codec;
694
}
695
696
12328
static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
697
{
698
12328
    char *codec_name = NULL;
699
700

16956
    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
701
12328
    if (codec_name) {
702
4622
        AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
703
4622
        st->codecpar->codec_id = codec->id;
704
4622
        return codec;
705
    } else
706
7706
        return avcodec_find_decoder(st->codecpar->codec_id);
707
}
708
709
/* Add all the streams from the given input file to the global
710
 * list of input streams. */
711
5893
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
712
{
713
    int i, ret;
714
715
12104
    for (i = 0; i < ic->nb_streams; i++) {
716
6211
        AVStream *st = ic->streams[i];
717
6211
        AVCodecParameters *par = st->codecpar;
718
6211
        InputStream *ist = av_mallocz(sizeof(*ist));
719
6211
        char *framerate = NULL, *hwaccel_device = NULL;
720
6211
        const char *hwaccel = NULL;
721
6211
        char *hwaccel_output_format = NULL;
722
6211
        char *codec_tag = NULL;
723
        char *next;
724
6211
        char *discard_str = NULL;
725
6211
        const AVClass *cc = avcodec_get_class();
726
6211
        const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
727
728
6211
        if (!ist)
729
            exit_program(1);
730
731
6211
        GROW_ARRAY(input_streams, nb_input_streams);
732
6211
        input_streams[nb_input_streams - 1] = ist;
733
734
6211
        ist->st = st;
735
6211
        ist->file_index = nb_input_files;
736
6211
        ist->discard = 1;
737
6211
        st->discard  = AVDISCARD_ALL;
738
6211
        ist->nb_samples = 0;
739
6211
        ist->min_pts = INT64_MAX;
740
6211
        ist->max_pts = INT64_MIN;
741
742
6211
        ist->ts_scale = 1.0;
743

6211
        MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
744
745
6211
        ist->autorotate = 1;
746

6211
        MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
747
748

6213
        MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
749
6211
        if (codec_tag) {
750
2
            uint32_t tag = strtol(codec_tag, &next, 0);
751
2
            if (*next)
752
2
                tag = AV_RL32(codec_tag);
753
2
            st->codecpar->codec_tag = tag;
754
        }
755
756
6211
        ist->dec = choose_decoder(o, ic, st);
757
6211
        ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
758
759
6211
        ist->reinit_filters = -1;
760

6211
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
761
762

6211
        MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
763
6211
        ist->user_set_discard = AVDISCARD_NONE;
764
765

6211
        if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
766

6211
            (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
767

6211
            (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
768

6211
            (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
769
                ist->user_set_discard = AVDISCARD_ALL;
770
771

6211
        if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
772
            av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
773
                    discard_str);
774
            exit_program(1);
775
        }
776
777
6211
        ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
778
779
6211
        ist->dec_ctx = avcodec_alloc_context3(ist->dec);
780
6211
        if (!ist->dec_ctx) {
781
            av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
782
            exit_program(1);
783
        }
784
785
6211
        ret = avcodec_parameters_to_context(ist->dec_ctx, par);
786
6211
        if (ret < 0) {
787
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
788
            exit_program(1);
789
        }
790
791
6211
        if (o->bitexact)
792
84
            ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
793
794

6211
        switch (par->codec_type) {
795
4786
        case AVMEDIA_TYPE_VIDEO:
796
4786
            if(!ist->dec)
797
21
                ist->dec = avcodec_find_decoder(par->codec_id);
798
#if FF_API_LOWRES
799
4786
            if (st->codec->lowres) {
800
1
                ist->dec_ctx->lowres = st->codec->lowres;
801
1
                ist->dec_ctx->width  = st->codec->width;
802
1
                ist->dec_ctx->height = st->codec->height;
803
1
                ist->dec_ctx->coded_width  = st->codec->coded_width;
804
1
                ist->dec_ctx->coded_height = st->codec->coded_height;
805
            }
806
#endif
807
808
            // avformat_find_stream_info() doesn't set this for us anymore.
809
4786
            ist->dec_ctx->framerate = st->avg_frame_rate;
810
811

4810
            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
812

4786
            if (framerate && av_parse_video_rate(&ist->framerate,
813
                                                 framerate) < 0) {
814
                av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
815
                       framerate);
816
                exit_program(1);
817
            }
818
819
4786
            ist->top_field_first = -1;
820

4786
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
821
822

9331
            MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
823
4786
            if (hwaccel) {
824
                // The NVDEC hwaccels use a CUDA device, so remap the name here.
825
4545
                if (!strcmp(hwaccel, "nvdec"))
826
                    hwaccel = "cuda";
827
828
4545
                if (!strcmp(hwaccel, "none"))
829
4545
                    ist->hwaccel_id = HWACCEL_NONE;
830
                else if (!strcmp(hwaccel, "auto"))
831
                    ist->hwaccel_id = HWACCEL_AUTO;
832
                else {
833
                    enum AVHWDeviceType type;
834
                    int i;
835
                    for (i = 0; hwaccels[i].name; i++) {
836
                        if (!strcmp(hwaccels[i].name, hwaccel)) {
837
                            ist->hwaccel_id = hwaccels[i].id;
838
                            break;
839
                        }
840
                    }
841
842
                    if (!ist->hwaccel_id) {
843
                        type = av_hwdevice_find_type_by_name(hwaccel);
844
                        if (type != AV_HWDEVICE_TYPE_NONE) {
845
                            ist->hwaccel_id = HWACCEL_GENERIC;
846
                            ist->hwaccel_device_type = type;
847
                        }
848
                    }
849
850
                    if (!ist->hwaccel_id) {
851
                        av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
852
                               hwaccel);
853
                        av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
854
                        type = AV_HWDEVICE_TYPE_NONE;
855
                        while ((type = av_hwdevice_iterate_types(type)) !=
856
                               AV_HWDEVICE_TYPE_NONE)
857
                            av_log(NULL, AV_LOG_FATAL, "%s ",
858
                                   av_hwdevice_get_type_name(type));
859
                        for (i = 0; hwaccels[i].name; i++)
860
                            av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
861
                        av_log(NULL, AV_LOG_FATAL, "\n");
862
                        exit_program(1);
863
                    }
864
                }
865
            }
866
867

4786
            MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
868
4786
            if (hwaccel_device) {
869
                ist->hwaccel_device = av_strdup(hwaccel_device);
870
                if (!ist->hwaccel_device)
871
                    exit_program(1);
872
            }
873
874

4786
            MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
875
                                 hwaccel_output_format, ic, st);
876
4786
            if (hwaccel_output_format) {
877
                ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
878
                if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
879
                    av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
880
                           "format: %s", hwaccel_output_format);
881
                }
882
            } else {
883
4786
                ist->hwaccel_output_format = AV_PIX_FMT_NONE;
884
            }
885
886
4786
            ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
887
888
4786
            break;
889
1333
        case AVMEDIA_TYPE_AUDIO:
890
1333
            ist->guess_layout_max = INT_MAX;
891

1337
            MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
892
1333
            guess_input_channel_layout(ist);
893
1333
            break;
894
91
        case AVMEDIA_TYPE_DATA:
895
        case AVMEDIA_TYPE_SUBTITLE: {
896
91
            char *canvas_size = NULL;
897
91
            if(!ist->dec)
898
48
                ist->dec = avcodec_find_decoder(par->codec_id);
899

91
            MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
900

91
            MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
901

91
            if (canvas_size &&
902
                av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
903
                av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
904
                exit_program(1);
905
            }
906
91
            break;
907
        }
908
1
        case AVMEDIA_TYPE_ATTACHMENT:
909
        case AVMEDIA_TYPE_UNKNOWN:
910
1
            break;
911
        default:
912
            abort();
913
        }
914
915
6211
        ret = avcodec_parameters_from_context(par, ist->dec_ctx);
916
6211
        if (ret < 0) {
917
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
918
            exit_program(1);
919
        }
920
    }
921
5893
}
922
923
5809
static void assert_file_overwrite(const char *filename)
924
{
925
5809
    const char *proto_name = avio_find_protocol_name(filename);
926
927

5809
    if (file_overwrite && no_file_overwrite) {
928
        fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
929
        exit_program(1);
930
    }
931
932
5809
    if (!file_overwrite) {
933

4350
        if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
934
            if (stdin_interaction && !no_file_overwrite) {
935
                fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
936
                fflush(stderr);
937
                term_exit();
938
                signal(SIGINT, SIG_DFL);
939
                if (!read_yesno()) {
940
                    av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
941
                    exit_program(1);
942
                }
943
                term_init();
944
            }
945
            else {
946
                av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
947
                exit_program(1);
948
            }
949
        }
950
    }
951
952

5809
    if (proto_name && !strcmp(proto_name, "file")) {
953
3201
        for (int i = 0; i < nb_input_files; i++) {
954
1621
             InputFile *file = input_files[i];
955
1621
             if (file->ctx->iformat->flags & AVFMT_NOFILE)
956
108
                 continue;
957
1513
             if (!strcmp(filename, file->ctx->url)) {
958
                 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
959
                 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
960
                 exit_program(1);
961
             }
962
        }
963
    }
964
5809
}
965
966
static void dump_attachment(AVStream *st, const char *filename)
967
{
968
    int ret;
969
    AVIOContext *out = NULL;
970
    AVDictionaryEntry *e;
971
972
    if (!st->codecpar->extradata_size) {
973
        av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
974
               nb_input_files - 1, st->index);
975
        return;
976
    }
977
    if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
978
        filename = e->value;
979
    if (!*filename) {
980
        av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
981
               "in stream #%d:%d.\n", nb_input_files - 1, st->index);
982
        exit_program(1);
983
    }
984
985
    assert_file_overwrite(filename);
986
987
    if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
988
        av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
989
               filename);
990
        exit_program(1);
991
    }
992
993
    avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
994
    avio_flush(out);
995
    avio_close(out);
996
}
997
998
5894
static int open_input_file(OptionsContext *o, const char *filename)
999
{
1000
    InputFile *f;
1001
    AVFormatContext *ic;
1002
5894
    AVInputFormat *file_iformat = NULL;
1003
    int err, i, ret;
1004
    int64_t timestamp;
1005
5894
    AVDictionary *unused_opts = NULL;
1006
5894
    AVDictionaryEntry *e = NULL;
1007
5894
    char *   video_codec_name = NULL;
1008
5894
    char *   audio_codec_name = NULL;
1009
5894
    char *subtitle_codec_name = NULL;
1010
5894
    char *    data_codec_name = NULL;
1011
5894
    int scan_all_pmts_set = 0;
1012
1013

5894
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1014
        o->stop_time = INT64_MAX;
1015
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1016
    }
1017
1018

5894
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1019
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1020
        if (o->stop_time <= start_time) {
1021
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1022
            exit_program(1);
1023
        } else {
1024
            o->recording_time = o->stop_time - start_time;
1025
        }
1026
    }
1027
1028
5894
    if (o->format) {
1029
2813
        if (!(file_iformat = av_find_input_format(o->format))) {
1030
            av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1031
            exit_program(1);
1032
        }
1033
    }
1034
1035
5894
    if (!strcmp(filename, "-"))
1036
        filename = "pipe:";
1037
1038
11788
    stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1039
5894
                         strcmp(filename, "/dev/stdin");
1040
1041
    /* get default parameters from command line */
1042
5894
    ic = avformat_alloc_context();
1043
5894
    if (!ic) {
1044
        print_error(filename, AVERROR(ENOMEM));
1045
        exit_program(1);
1046
    }
1047
5894
    if (o->nb_audio_sample_rate) {
1048
63
        av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1049
    }
1050
5894
    if (o->nb_audio_channels) {
1051
        /* because we set audio_channels based on both the "ac" and
1052
         * "channel_layout" options, we need to check that the specified
1053
         * demuxer actually has the "channels" option before setting it */
1054

18
        if (file_iformat && file_iformat->priv_class &&
1055
9
            av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1056
                        AV_OPT_SEARCH_FAKE_OBJ)) {
1057
9
            av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1058
        }
1059
    }
1060
5894
    if (o->nb_frame_rates) {
1061
        /* set the format-level framerate option;
1062
         * this is important for video grabbers, e.g. x11 */
1063

48
        if (file_iformat && file_iformat->priv_class &&
1064
24
            av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1065
                        AV_OPT_SEARCH_FAKE_OBJ)) {
1066
24
            av_dict_set(&o->g->format_opts, "framerate",
1067
24
                        o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1068
        }
1069
    }
1070
5894
    if (o->nb_frame_sizes) {
1071
492
        av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1072
    }
1073
5894
    if (o->nb_frame_pix_fmts)
1074
497
        av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1075
1076

8205
    MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
1077

8205
    MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
1078

8205
    MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1079

8205
    MATCH_PER_TYPE_OPT(codec_names, str,     data_codec_name, ic, "d");
1080
1081
5894
    if (video_codec_name)
1082
2278
        ic->video_codec    = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
1083
5894
    if (audio_codec_name)
1084
16
        ic->audio_codec    = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
1085
5894
    if (subtitle_codec_name)
1086
        ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1087
5894
    if (data_codec_name)
1088
        ic->data_codec     = find_codec_or_die(data_codec_name    , AVMEDIA_TYPE_DATA    , 0);
1089
1090
5894
    ic->video_codec_id     = video_codec_name    ? ic->video_codec->id    : AV_CODEC_ID_NONE;
1091
5894
    ic->audio_codec_id     = audio_codec_name    ? ic->audio_codec->id    : AV_CODEC_ID_NONE;
1092
5894
    ic->subtitle_codec_id  = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1093
5894
    ic->data_codec_id      = data_codec_name     ? ic->data_codec->id     : AV_CODEC_ID_NONE;
1094
1095
5894
    ic->flags |= AVFMT_FLAG_NONBLOCK;
1096
5894
    if (o->bitexact)
1097
75
        ic->flags |= AVFMT_FLAG_BITEXACT;
1098
5894
    ic->interrupt_callback = int_cb;
1099
1100
5894
    if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1101
5894
        av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1102
5894
        scan_all_pmts_set = 1;
1103
    }
1104
    /* open the input file with generic avformat function */
1105
5894
    err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1106
5894
    if (err < 0) {
1107
1
        print_error(filename, err);
1108
1
        if (err == AVERROR_PROTOCOL_NOT_FOUND)
1109
            av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1110
1
        exit_program(1);
1111
    }
1112
5893
    if (scan_all_pmts_set)
1113
5893
        av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1114
5893
    remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1115
5893
    assert_avoptions(o->g->format_opts);
1116
1117
    /* apply forced codec ids */
1118
12010
    for (i = 0; i < ic->nb_streams; i++)
1119
6117
        choose_decoder(o, ic, ic->streams[i]);
1120
1121
5893
    if (find_stream_info) {
1122
5893
        AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1123
5893
        int orig_nb_streams = ic->nb_streams;
1124
1125
        /* If not enough info to get the stream parameters, we decode the
1126
           first frames to get it. (used in mpeg case for example) */
1127
5893
        ret = avformat_find_stream_info(ic, opts);
1128
1129
12010
        for (i = 0; i < orig_nb_streams; i++)
1130
6117
            av_dict_free(&opts[i]);
1131
5893
        av_freep(&opts);
1132
1133
5893
        if (ret < 0) {
1134
            av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1135
            if (ic->nb_streams == 0) {
1136
                avformat_close_input(&ic);
1137
                exit_program(1);
1138
            }
1139
        }
1140
    }
1141
1142

5893
    if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1143
        av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1144
        o->start_time_eof = AV_NOPTS_VALUE;
1145
    }
1146
1147
5893
    if (o->start_time_eof != AV_NOPTS_VALUE) {
1148
        if (o->start_time_eof >= 0) {
1149
            av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1150
            exit_program(1);
1151
        }
1152
        if (ic->duration > 0) {
1153
            o->start_time = o->start_time_eof + ic->duration;
1154
            if (o->start_time < 0) {
1155
                av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1156
                o->start_time = AV_NOPTS_VALUE;
1157
            }
1158
        } else
1159
            av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1160
    }
1161
5893
    timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1162
    /* add the stream start time */
1163

5893
    if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1164
4433
        timestamp += ic->start_time;
1165
1166
    /* if seeking requested, we execute it */
1167
5893
    if (o->start_time != AV_NOPTS_VALUE) {
1168
21
        int64_t seek_timestamp = timestamp;
1169
1170
21
        if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1171
21
            int dts_heuristic = 0;
1172
42
            for (i=0; i<ic->nb_streams; i++) {
1173
21
                const AVCodecParameters *par = ic->streams[i]->codecpar;
1174
21
                if (par->video_delay) {
1175
                    dts_heuristic = 1;
1176
                    break;
1177
                }
1178
            }
1179
21
            if (dts_heuristic) {
1180
                seek_timestamp -= 3*AV_TIME_BASE / 23;
1181
            }
1182
        }
1183
21
        ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1184
21
        if (ret < 0) {
1185
1
            av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1186
1
                   filename, (double)timestamp / AV_TIME_BASE);
1187
        }
1188
    }
1189
1190
    /* update the current parameters so that they match the one of the input stream */
1191
5893
    add_input_streams(o, ic);
1192
1193
    /* dump the file content */
1194
5893
    av_dump_format(ic, nb_input_files, filename, 0);
1195
1196
5893
    GROW_ARRAY(input_files, nb_input_files);
1197
5893
    f = av_mallocz(sizeof(*f));
1198
5893
    if (!f)
1199
        exit_program(1);
1200
5893
    input_files[nb_input_files - 1] = f;
1201
1202
5893
    f->ctx        = ic;
1203
5893
    f->ist_index  = nb_input_streams - ic->nb_streams;
1204
5893
    f->start_time = o->start_time;
1205
5893
    f->recording_time = o->recording_time;
1206
5893
    f->input_ts_offset = o->input_ts_offset;
1207

5893
    f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1208
5893
    f->nb_streams = ic->nb_streams;
1209
5893
    f->rate_emu   = o->rate_emu;
1210
5893
    f->accurate_seek = o->accurate_seek;
1211
5893
    f->loop = o->loop;
1212
5893
    f->duration = 0;
1213
5893
    f->time_base = (AVRational){ 1, 1 };
1214
#if HAVE_THREADS
1215
5893
    f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1216
#endif
1217
1218
    /* check if all codec options have been used */
1219
5893
    unused_opts = strip_specifiers(o->g->codec_opts);
1220
12104
    for (i = f->ist_index; i < nb_input_streams; i++) {
1221
6211
        e = NULL;
1222
25238
        while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1223
                                AV_DICT_IGNORE_SUFFIX)))
1224
19027
            av_dict_set(&unused_opts, e->key, NULL, 0);
1225
    }
1226
1227
5893
    e = NULL;
1228
6145
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1229
252
        const AVClass *class = avcodec_get_class();
1230
252
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1231
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1232
252
        const AVClass *fclass = avformat_get_class();
1233
252
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1234
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1235

252
        if (!option || foption)
1236
            continue;
1237
1238
1239
252
        if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1240
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1241
                   "input file #%d (%s) is not a decoding option.\n", e->key,
1242
                   option->help ? option->help : "", nb_input_files - 1,
1243
                   filename);
1244
            exit_program(1);
1245
        }
1246
1247
252
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1248
               "input file #%d (%s) has not been used for any stream. The most "
1249
               "likely reason is either wrong type (e.g. a video option with "
1250
               "no video streams) or that it is a private option of some decoder "
1251
               "which was not actually used for any stream.\n", e->key,
1252
252
               option->help ? option->help : "", nb_input_files - 1, filename);
1253
    }
1254
5893
    av_dict_free(&unused_opts);
1255
1256
5893
    for (i = 0; i < o->nb_dump_attachment; i++) {
1257
        int j;
1258
1259
        for (j = 0; j < ic->nb_streams; j++) {
1260
            AVStream *st = ic->streams[j];
1261
1262
            if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1263
                dump_attachment(st, o->dump_attachment[i].u.str);
1264
        }
1265
    }
1266
1267
5893
    input_stream_potentially_available = 1;
1268
1269
5893
    return 0;
1270
}
1271
1272
static uint8_t *get_line(AVIOContext *s)
1273
{
1274
    AVIOContext *line;
1275
    uint8_t *buf;
1276
    char c;
1277
1278
    if (avio_open_dyn_buf(&line) < 0) {
1279
        av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1280
        exit_program(1);
1281
    }
1282
1283
    while ((c = avio_r8(s)) && c != '\n')
1284
        avio_w8(line, c);
1285
    avio_w8(line, 0);
1286
    avio_close_dyn_buf(line, &buf);
1287
1288
    return buf;
1289
}
1290
1291
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1292
{
1293
    int i, ret = -1;
1294
    char filename[1000];
1295
    const char *base[3] = { getenv("AVCONV_DATADIR"),
1296
                            getenv("HOME"),
1297
                            AVCONV_DATADIR,
1298
                            };
1299
1300
    for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1301
        if (!base[i])
1302
            continue;
1303
        if (codec_name) {
1304
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1305
                     i != 1 ? "" : "/.avconv", codec_name, preset_name);
1306
            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1307
        }
1308
        if (ret < 0) {
1309
            snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1310
                     i != 1 ? "" : "/.avconv", preset_name);
1311
            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1312
        }
1313
    }
1314
    return ret;
1315
}
1316
1317
6005
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1318
{
1319
6005
    enum AVMediaType type = ost->st->codecpar->codec_type;
1320
6005
    char *codec_name = NULL;
1321
1322

6005
    if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1323

9508
        MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1324
5994
        if (!codec_name) {
1325
5218
            ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1326
2609
                                                         NULL, ost->st->codecpar->codec_type);
1327
2609
            ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1328
2609
            if (!ost->enc) {
1329
                av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1330
                       "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1331
                       "probably disabled. Please choose an encoder manually.\n",
1332
                       ost->file_index, ost->index, s->oformat->name,
1333
                       avcodec_get_name(ost->st->codecpar->codec_id));
1334
                return AVERROR_ENCODER_NOT_FOUND;
1335
            }
1336
3385
        } else if (!strcmp(codec_name, "copy"))
1337
279
            ost->stream_copy = 1;
1338
        else {
1339
3106
            ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1340
3106
            ost->st->codecpar->codec_id = ost->enc->id;
1341
        }
1342
5994
        ost->encoding_needed = !ost->stream_copy;
1343
    } else {
1344
        /* no encoding supported for other media types */
1345
11
        ost->stream_copy     = 1;
1346
11
        ost->encoding_needed = 0;
1347
    }
1348
1349
6005
    return 0;
1350
}
1351
1352
6005
static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1353
{
1354
    OutputStream *ost;
1355
6005
    AVStream *st = avformat_new_stream(oc, NULL);
1356
6005
    int idx      = oc->nb_streams - 1, ret = 0;
1357
6005
    const char *bsfs = NULL, *time_base = NULL;
1358
6005
    char *next, *codec_tag = NULL;
1359
6005
    double qscale = -1;
1360
    int i;
1361
1362
6005
    if (!st) {
1363
        av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1364
        exit_program(1);
1365
    }
1366
1367
6005
    if (oc->nb_streams - 1 < o->nb_streamid_map)
1368
        st->id = o->streamid_map[oc->nb_streams - 1];
1369
1370
6005
    GROW_ARRAY(output_streams, nb_output_streams);
1371
6005
    if (!(ost = av_mallocz(sizeof(*ost))))
1372
        exit_program(1);
1373
6005
    output_streams[nb_output_streams - 1] = ost;
1374
1375
6005
    ost->file_index = nb_output_files - 1;
1376
6005
    ost->index      = idx;
1377
6005
    ost->st         = st;
1378
6005
    ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1379
6005
    st->codecpar->codec_type = type;
1380
1381
6005
    ret = choose_encoder(o, oc, ost);
1382
6005
    if (ret < 0) {
1383
        av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1384
               "%d:%d\n", ost->file_index, ost->index);
1385
        exit_program(1);
1386
    }
1387
1388
6005
    ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1389
6005
    if (!ost->enc_ctx) {
1390
        av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1391
        exit_program(1);
1392
    }
1393
6005
    ost->enc_ctx->codec_type = type;
1394
1395
6005
    ost->ref_par = avcodec_parameters_alloc();
1396
6005
    if (!ost->ref_par) {
1397
        av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1398
        exit_program(1);
1399
    }
1400
1401
6005
    if (ost->enc) {
1402
5715
        AVIOContext *s = NULL;
1403
5715
        char *buf = NULL, *arg = NULL, *preset = NULL;
1404
1405
5715
        ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1406
1407

5715
        MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1408

5715
        if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1409
            do  {
1410
                buf = get_line(s);
1411
                if (!buf[0] || buf[0] == '#') {
1412
                    av_free(buf);
1413
                    continue;
1414
                }
1415
                if (!(arg = strchr(buf, '='))) {
1416
                    av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1417
                    exit_program(1);
1418
                }
1419
                *arg++ = 0;
1420
                av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1421
                av_free(buf);
1422
            } while (!s->eof_reached);
1423
            avio_closep(&s);
1424
        }
1425
5715
        if (ret) {
1426
            av_log(NULL, AV_LOG_FATAL,
1427
                   "Preset %s specified for stream %d:%d, but could not be opened.\n",
1428
                   preset, ost->file_index, ost->index);
1429
            exit_program(1);
1430
        }
1431
    } else {
1432
290
        ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1433
    }
1434
1435
1436
6005
    if (o->bitexact)
1437
1664
        ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1438
1439

6006
    MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1440
6005
    if (time_base) {
1441
        AVRational q;
1442
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1443

1
            q.num <= 0 || q.den <= 0) {
1444
            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1445
            exit_program(1);
1446
        }
1447
1
        st->time_base = q;
1448
    }
1449
1450

6005
    MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1451
6005
    if (time_base) {
1452
        AVRational q;
1453
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1454
1
            q.den <= 0) {
1455
            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1456
            exit_program(1);
1457
        }
1458
1
        ost->enc_timebase = q;
1459
    }
1460
1461
6005
    ost->max_frames = INT64_MAX;
1462

10158
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1463
10152
    for (i = 0; i<o->nb_max_frames; i++) {
1464
4153
        char *p = o->max_frames[i].specifier;
1465

4153
        if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1466
6
            av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1467
6
            break;
1468
        }
1469
    }
1470
1471
6005
    ost->copy_prior_start = -1;
1472

6005
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1473
1474

6089
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1475

6089
    while (bsfs && *bsfs) {
1476
        const AVBitStreamFilter *filter;
1477
        char *bsf, *bsf_options_str, *bsf_name;
1478
1479
84
        bsf = av_get_token(&bsfs, ",");
1480
84
        if (!bsf)
1481
            exit_program(1);
1482
84
        bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1483
84
        if (!bsf_name)
1484
            exit_program(1);
1485
1486
84
        filter = av_bsf_get_by_name(bsf_name);
1487
84
        if (!filter) {
1488
            av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1489
            exit_program(1);
1490
        }
1491
1492
168
        ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1493
84
                                        ost->nb_bitstream_filters + 1,
1494
                                        sizeof(*ost->bsf_ctx));
1495
84
        if (!ost->bsf_ctx)
1496
            exit_program(1);
1497
1498
84
        ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1499
84
        if (ret < 0) {
1500
            av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1501
            exit_program(1);
1502
        }
1503
1504
84
        ost->nb_bitstream_filters++;
1505
1506

84
        if (bsf_options_str && filter->priv_class) {
1507
10
            const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1508
10
            const char * shorthand[2] = {NULL};
1509
1510
10
            if (opt)
1511
10
                shorthand[0] = opt->name;
1512
1513
10
            ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1514
10
            if (ret < 0) {
1515
                av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1516
                exit_program(1);
1517
            }
1518
        }
1519
84
        av_freep(&bsf);
1520
1521
84
        if (*bsfs)
1522
            bsfs++;
1523
    }
1524
1525

6011
    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1526
6005
    if (codec_tag) {
1527
6
        uint32_t tag = strtol(codec_tag, &next, 0);
1528
6
        if (*next)
1529
6
            tag = AV_RL32(codec_tag);
1530
6
        ost->st->codecpar->codec_tag =
1531
6
        ost->enc_ctx->codec_tag = tag;
1532
    }
1533
1534

6289
    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1535
6005
    if (qscale >= 0) {
1536
232
        ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1537
232
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1538
    }
1539
1540

6005
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1541
6005
    ost->disposition = av_strdup(ost->disposition);
1542
1543
6005
    ost->max_muxing_queue_size = 128;
1544

6007
    MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1545
6005
    ost->max_muxing_queue_size *= sizeof(AVPacket);
1546
1547
6005
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1548
2282
        ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1549
1550
6005
    av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1551
1552
6005
    av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1553

6005
    if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1554
52
        av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1555
1556
6005
    av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1557
1558
6005
    ost->source_index = source_index;
1559
6005
    if (source_index >= 0) {
1560
5929
        ost->sync_ist = input_streams[source_index];
1561
5929
        input_streams[source_index]->discard = 0;
1562
5929
        input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1563
    }
1564
6005
    ost->last_mux_dts = AV_NOPTS_VALUE;
1565
1566
6005
    ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1567
6005
    if (!ost->muxing_queue)
1568
        exit_program(1);
1569
1570
6005
    return ost;
1571
}
1572
1573
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1574
{
1575
    int i;
1576
    const char *p = str;
1577
    for (i = 0;; i++) {
1578
        dest[i] = atoi(p);
1579
        if (i == 63)
1580
            break;
1581
        p = strchr(p, ',');
1582
        if (!p) {
1583
            av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1584
            exit_program(1);
1585
        }
1586
        p++;
1587
    }
1588
}
1589
1590
/* read file contents into a string */
1591
26
static uint8_t *read_file(const char *filename)
1592
{
1593
26
    AVIOContext *pb      = NULL;
1594
26
    AVIOContext *dyn_buf = NULL;
1595
26
    int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1596
    uint8_t buf[1024], *str;
1597
1598
26
    if (ret < 0) {
1599
        av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1600
        return NULL;
1601
    }
1602
1603
26
    ret = avio_open_dyn_buf(&dyn_buf);
1604
26
    if (ret < 0) {
1605
        avio_closep(&pb);
1606
        return NULL;
1607
    }
1608
52
    while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1609
26
        avio_write(dyn_buf, buf, ret);
1610
26
    avio_w8(dyn_buf, 0);
1611
26
    avio_closep(&pb);
1612
1613
26
    ret = avio_close_dyn_buf(dyn_buf, &str);
1614
26
    if (ret < 0)
1615
        return NULL;
1616
26
    return str;
1617
}
1618
1619
5685
static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1620
                             OutputStream *ost)
1621
{
1622
5685
    AVStream *st = ost->st;
1623
1624

5685
    if (ost->filters_script && ost->filters) {
1625
        av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1626
               "output stream #%d:%d.\n", nb_output_files, st->index);
1627
        exit_program(1);
1628
    }
1629
1630
5685
    if (ost->filters_script)
1631
4
        return read_file(ost->filters_script);
1632
5681
    else if (ost->filters)
1633
2556
        return av_strdup(ost->filters);
1634
1635
3125
    return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1636
                     "null" : "anull");
1637
}
1638
1639
272
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1640
                                     const OutputStream *ost, enum AVMediaType type)
1641
{
1642

272
    if (ost->filters_script || ost->filters) {
1643
        av_log(NULL, AV_LOG_ERROR,
1644
               "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1645
               "Filtering and streamcopy cannot be used together.\n",
1646
               ost->filters ? "Filtergraph" : "Filtergraph script",
1647
               ost->filters ? ost->filters : ost->filters_script,
1648
               av_get_media_type_string(type), ost->file_index, ost->index);
1649
        exit_program(1);
1650
    }
1651
272
}
1652
1653
4764
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1654
{
1655
    AVStream *st;
1656
    OutputStream *ost;
1657
    AVCodecContext *video_enc;
1658
4764
    char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1659
1660
4764
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1661
4764
    st  = ost->st;
1662
4764
    video_enc = ost->enc_ctx;
1663
1664

4785
    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1665

4764
    if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1666
        av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1667
        exit_program(1);
1668
    }
1669

4764
    if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1670
        av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1671
1672

4764
    MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1673
4764
    if (frame_aspect_ratio) {
1674
        AVRational q;
1675
        if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1676
            q.num <= 0 || q.den <= 0) {
1677
            av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1678
            exit_program(1);
1679
        }
1680
        ost->frame_aspect_ratio = q;
1681
    }
1682
1683

4767
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1684

6930
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1685
4764
    if (o->nb_filters > 1)
1686
        av_log(NULL, AV_LOG_ERROR, "Only '-vf %s' read, ignoring remaining -vf options: Use ',' to separate filters\n", ost->filters);
1687
1688
4764
    if (!ost->stream_copy) {
1689
4593
        const char *p = NULL;
1690
4593
        char *frame_size = NULL;
1691
4593
        char *frame_pix_fmt = NULL;
1692
4593
        char *intra_matrix = NULL, *inter_matrix = NULL;
1693
4593
        char *chroma_intra_matrix = NULL;
1694
4593
        int do_pass = 0;
1695
        int i;
1696
1697

5205
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1698

4593
        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1699
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1700
            exit_program(1);
1701
        }
1702
1703
4593
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1704

7889
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1705

4593
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
1706
            ost->keep_pix_fmt = 1;
1707
            if (!*++frame_pix_fmt)
1708
                frame_pix_fmt = NULL;
1709
        }
1710

4593
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1711
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1712
            exit_program(1);
1713
        }
1714
4593
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1715
1716
4593
        if (intra_only)
1717
            video_enc->gop_size = 0;
1718

4593
        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1719
4593
        if (intra_matrix) {
1720
            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1721
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1722
                exit_program(1);
1723
            }
1724
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1725
        }
1726

4593
        MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1727
4593
        if (chroma_intra_matrix) {
1728
            uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1729
            if (!p) {
1730
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1731
                exit_program(1);
1732
            }
1733
            video_enc->chroma_intra_matrix = p;
1734
            parse_matrix_coeffs(p, chroma_intra_matrix);
1735
        }
1736

4593
        MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1737
4593
        if (inter_matrix) {
1738
            if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1739
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1740
                exit_program(1);
1741
            }
1742
            parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1743
        }
1744
1745

4593
        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1746
4593
        for (i = 0; p; i++) {
1747
            int start, end, q;
1748
            int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1749
            if (e != 3) {
1750
                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1751
                exit_program(1);
1752
            }
1753
            video_enc->rc_override =
1754
                av_realloc_array(video_enc->rc_override,
1755
                                 i + 1, sizeof(RcOverride));
1756
            if (!video_enc->rc_override) {
1757
                av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1758
                exit_program(1);
1759
            }
1760
            video_enc->rc_override[i].start_frame = start;
1761
            video_enc->rc_override[i].end_frame   = end;
1762
            if (q > 0) {
1763
                video_enc->rc_override[i].qscale         = q;
1764
                video_enc->rc_override[i].quality_factor = 1.0;
1765
            }
1766
            else {
1767
                video_enc->rc_override[i].qscale         = 0;
1768
                video_enc->rc_override[i].quality_factor = -q/100.0;
1769
            }
1770
            p = strchr(p, '/');
1771
            if (p) p++;
1772
        }
1773
4593
        video_enc->rc_override_count = i;
1774
1775
4593
        if (do_psnr)
1776
            video_enc->flags|= AV_CODEC_FLAG_PSNR;
1777
1778
        /* two pass mode */
1779

4593
        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1780
4593
        if (do_pass) {
1781
            if (do_pass & 1) {
1782
                video_enc->flags |= AV_CODEC_FLAG_PASS1;
1783
                av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1784
            }
1785
            if (do_pass & 2) {
1786
                video_enc->flags |= AV_CODEC_FLAG_PASS2;
1787
                av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1788
            }
1789
        }
1790
1791

4593
        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1792
4593
        if (ost->logfile_prefix &&
1793
            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1794
            exit_program(1);
1795
1796
4593
        if (do_pass) {
1797
            char logfilename[1024];
1798
            FILE *f;
1799
1800
            snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1801
                     ost->logfile_prefix ? ost->logfile_prefix :
1802
                                           DEFAULT_PASS_LOGFILENAME_PREFIX,
1803
                     i);
1804
            if (!strcmp(ost->enc->name, "libx264")) {
1805
                av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1806
            } else {
1807
                if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1808
                    char  *logbuffer = read_file(logfilename);
1809
1810
                    if (!logbuffer) {
1811
                        av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1812
                               logfilename);
1813
                        exit_program(1);
1814
                    }
1815
                    video_enc->stats_in = logbuffer;
1816
                }
1817
                if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1818
                    f = av_fopen_utf8(logfilename, "wb");
1819
                    if (!f) {
1820
                        av_log(NULL, AV_LOG_FATAL,
1821
                               "Cannot write log file '%s' for pass-1 encoding: %s\n",
1822
                               logfilename, strerror(errno));
1823
                        exit_program(1);
1824
                    }
1825
                    ost->logfile = f;
1826
                }
1827
            }
1828
        }
1829
1830

4594
        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1831
4593
        if (ost->forced_keyframes)
1832
1
            ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1833
1834

4593
        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1835
1836
4593
        ost->top_field_first = -1;
1837

4596
        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1838
1839
1840
4593
        ost->avfilter = get_ost_filters(o, oc, ost);
1841
4593
        if (!ost->avfilter)
1842
            exit_program(1);
1843
    } else {
1844

171
        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1845
    }
1846
1847
4764
    if (ost->stream_copy)
1848
171
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1849
1850
4764
    return ost;
1851
}
1852
1853
1193
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1854
{
1855
    int n;
1856
    AVStream *st;
1857
    OutputStream *ost;
1858
    AVCodecContext *audio_enc;
1859
1860
1193
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1861
1193
    st  = ost->st;
1862
1863
1193
    audio_enc = ost->enc_ctx;
1864
1193
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1865
1866

1194
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1867

1591
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1868
1193
    if (o->nb_filters > 1)
1869
        av_log(NULL, AV_LOG_ERROR, "Only '-af %s' read, ignoring remaining -af options: Use ',' to separate filters\n", ost->filters);
1870
1871
1193
    if (!ost->stream_copy) {
1872
1092
        char *sample_fmt = NULL;
1873
1874

1104
        MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1875
1876

1092
        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1877
1092
        if (sample_fmt &&
1878
            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1879
            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1880
            exit_program(1);
1881
        }
1882
1883

1117
        MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1884
1885

1092
        MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1886
1092
        ost->apad = av_strdup(ost->apad);
1887
1888
1092
        ost->avfilter = get_ost_filters(o, oc, ost);
1889
1092
        if (!ost->avfilter)
1890
            exit_program(1);
1891
1892
        /* check for channel mapping for this audio stream */
1893
1102
        for (n = 0; n < o->nb_audio_channel_maps; n++) {
1894
10
            AudioChannelMap *map = &o->audio_channel_maps[n];
1895

10
            if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1896

10
                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1897
                InputStream *ist;
1898
1899
10
                if (map->channel_idx == -1) {
1900
1
                    ist = NULL;
1901
9
                } else if (ost->source_index < 0) {
1902
                    av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1903
                           ost->file_index, ost->st->index);
1904
                    continue;
1905
                } else {
1906
9
                    ist = input_streams[ost->source_index];
1907
                }
1908
1909

10
                if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1910
10
                    if (av_reallocp_array(&ost->audio_channels_map,
1911
10
                                          ost->audio_channels_mapped + 1,
1912
                                          sizeof(*ost->audio_channels_map)
1913
                                          ) < 0 )
1914
                        exit_program(1);
1915
1916
10
                    ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1917
                }
1918
            }
1919
        }
1920
    }
1921
1922
1193
    if (ost->stream_copy)
1923
101
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1924
1925
1193
    return ost;
1926
}
1927
1928
10
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1929
{
1930
    OutputStream *ost;
1931
1932
10
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1933
10
    if (!ost->stream_copy) {
1934
        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1935
        exit_program(1);
1936
    }
1937
1938
10
    return ost;
1939
}
1940
1941
static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1942
{
1943
    OutputStream *ost;
1944
1945
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1946
    if (!ost->stream_copy) {
1947
        av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1948
        exit_program(1);
1949
    }
1950
1951
    return ost;
1952
}
1953
1954
1
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1955
{
1956
1
    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1957
1
    ost->stream_copy = 1;
1958
1
    ost->finished    = 1;
1959
1
    return ost;
1960
}
1961
1962
37
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1963
{
1964
    AVStream *st;
1965
    OutputStream *ost;
1966
    AVCodecContext *subtitle_enc;
1967
1968
37
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1969
37
    st  = ost->st;
1970
37
    subtitle_enc = ost->enc_ctx;
1971
1972
37
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1973
1974

37
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1975
1976
37
    if (!ost->stream_copy) {
1977
30
        char *frame_size = NULL;
1978
1979

30
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1980

30
        if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1981
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1982
            exit_program(1);
1983
        }
1984
    }
1985
1986
37
    return ost;
1987
}
1988
1989
/* arg format is "output-stream-index:streamid-value". */
1990
static int opt_streamid(void *optctx, const char *opt, const char *arg)
1991
{
1992
    OptionsContext *o = optctx;
1993
    int idx;
1994
    char *p;
1995
    char idx_str[16];
1996
1997
    av_strlcpy(idx_str, arg, sizeof(idx_str));
1998
    p = strchr(idx_str, ':');
1999
    if (!p) {
2000
        av_log(NULL, AV_LOG_FATAL,
2001
               "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2002
               arg, opt);
2003
        exit_program(1);
2004
    }
2005
    *p++ = '\0';
2006
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2007
    o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2008
    o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2009
    return 0;
2010
}
2011
2012
10
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2013
{
2014
10
    AVFormatContext *is = ifile->ctx;
2015
10
    AVFormatContext *os = ofile->ctx;
2016
    AVChapter **tmp;
2017
    int i;
2018
2019
10
    tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2020
10
    if (!tmp)
2021
        return AVERROR(ENOMEM);
2022
10
    os->chapters = tmp;
2023
2024
20
    for (i = 0; i < is->nb_chapters; i++) {
2025
10
        AVChapter *in_ch = is->chapters[i], *out_ch;
2026
10
        int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2027
10
        int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
2028
10
                                       AV_TIME_BASE_Q, in_ch->time_base);
2029
10
        int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2030
                           av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2031
2032
2033
10
        if (in_ch->end < ts_off)
2034
            continue;
2035

10
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2036
            break;
2037
2038
10
        out_ch = av_mallocz(sizeof(AVChapter));
2039
10
        if (!out_ch)
2040
            return AVERROR(ENOMEM);
2041
2042
10
        out_ch->id        = in_ch->id;
2043
10
        out_ch->time_base = in_ch->time_base;
2044
10
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
2045
10
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
2046
2047
10
        if (copy_metadata)
2048
10
            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2049
2050
10
        os->chapters[os->nb_chapters++] = out_ch;
2051
    }
2052
10
    return 0;
2053
}
2054
2055
75
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2056
                               AVFormatContext *oc)
2057
{
2058
    OutputStream *ost;
2059
2060
75
    switch (ofilter->type) {
2061
60
    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2062
15
    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2063
    default:
2064
        av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2065
               "currently.\n");
2066
        exit_program(1);
2067
    }
2068
2069
75
    ost->source_index = -1;
2070
75
    ost->filter       = ofilter;
2071
2072
75
    ofilter->ost      = ost;
2073
75
    ofilter->format   = -1;
2074
2075
75
    if (ost->stream_copy) {
2076
        av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2077
               "which is fed from a complex filtergraph. Filtering and streamcopy "
2078
               "cannot be used together.\n", ost->file_index, ost->index);
2079
        exit_program(1);
2080
    }
2081
2082

75
    if (ost->avfilter && (ost->filters || ost->filters_script)) {
2083
        const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2084
        av_log(NULL, AV_LOG_ERROR,
2085
               "%s '%s' was specified through the %s option "
2086
               "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2087
               "%s and -filter_complex cannot be used together for the same stream.\n",
2088
               ost->filters ? "Filtergraph" : "Filtergraph script",
2089
               ost->filters ? ost->filters : ost->filters_script,
2090
               opt, ost->file_index, ost->index, opt);
2091
        exit_program(1);
2092
    }
2093
2094
75
    avfilter_inout_free(&ofilter->out_tmp);
2095
75
}
2096
2097
5861
static int init_complex_filters(void)
2098
{
2099
5861
    int i, ret = 0;
2100
2101
5933
    for (i = 0; i < nb_filtergraphs; i++) {
2102
72
        ret = init_complex_filtergraph(filtergraphs[i]);
2103
72
        if (ret < 0)
2104
            return ret;
2105
    }
2106
5861
    return 0;
2107
}
2108
2109
5862
static int open_output_file(OptionsContext *o, const char *filename)
2110
{
2111
    AVFormatContext *oc;
2112
    int i, j, err;
2113
    OutputFile *of;
2114
    OutputStream *ost;
2115
    InputStream  *ist;
2116
5862
    AVDictionary *unused_opts = NULL;
2117
5862
    AVDictionaryEntry *e = NULL;
2118
5862
    int format_flags = 0;
2119
2120

5862
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2121
        o->stop_time = INT64_MAX;
2122
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2123
    }
2124
2125

5862
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2126
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2127
        if (o->stop_time <= start_time) {
2128
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2129
            exit_program(1);
2130
        } else {
2131
            o->recording_time = o->stop_time - start_time;
2132
        }
2133
    }
2134
2135
5862
    GROW_ARRAY(output_files, nb_output_files);
2136
5862
    of = av_mallocz(sizeof(*of));
2137
5862
    if (!of)
2138
        exit_program(1);
2139
5862
    output_files[nb_output_files - 1] = of;
2140
2141
5862
    of->ost_index      = nb_output_streams;
2142
5862
    of->recording_time = o->recording_time;
2143
5862
    of->start_time     = o->start_time;
2144
5862
    of->limit_filesize = o->limit_filesize;
2145
5862
    of->shortest       = o->shortest;
2146
5862
    av_dict_copy(&of->opts, o->g->format_opts, 0);
2147
2148
5862
    if (!strcmp(filename, "-"))
2149
2190
        filename = "pipe:";
2150
2151
5862
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2152
5862
    if (!oc) {
2153
        print_error(filename, err);
2154
        exit_program(1);
2155
    }
2156
2157
5862
    of->ctx = oc;
2158
5862
    if (o->recording_time != INT64_MAX)
2159
125
        oc->duration = o->recording_time;
2160
2161
5862
    oc->interrupt_callback = int_cb;
2162
2163
5862
    e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2164
5862
    if (e) {
2165
3336
        const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2166
3336
        av_opt_eval_flags(oc, o, e->value, &format_flags);
2167
    }
2168
5862
    if (o->bitexact) {
2169
1617
        format_flags |= AVFMT_FLAG_BITEXACT;
2170
1617
        oc->flags    |= AVFMT_FLAG_BITEXACT;
2171
    }
2172
2173
    /* create streams for all unlabeled output pads */
2174
5935
    for (i = 0; i < nb_filtergraphs; i++) {
2175
73
        FilterGraph *fg = filtergraphs[i];
2176
149
        for (j = 0; j < fg->nb_outputs; j++) {
2177
76
            OutputFilter *ofilter = fg->outputs[j];
2178
2179

76
            if (!ofilter->out_tmp || ofilter->out_tmp->name)
2180
4
                continue;
2181
2182

72
            switch (ofilter->type) {
2183
58
            case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2184
14
            case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2185
            case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2186
            }
2187
72
            init_output_filter(ofilter, o, oc);
2188
        }
2189
    }
2190
2191
5862
    if (!o->nb_stream_maps) {
2192
5819
        char *subtitle_codec_name = NULL;
2193
        /* pick the "best" stream of each type */
2194
2195
        /* video: highest resolution */
2196

5819
        if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2197
4922
            int area = 0, idx = -1;
2198
4922
            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2199
10123
            for (i = 0; i < nb_input_streams; i++) {
2200
                int new_area;
2201
5201
                ist = input_streams[i];
2202
5201
                new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2203
5201
                           + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2204
5201
                if (ist->user_set_discard == AVDISCARD_ALL)
2205
                    continue;
2206

5201
                if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2207
8
                    new_area = 1;
2208

5201
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2209
                    new_area > area) {
2210

4681
                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2211
                        continue;
2212
4681
                    area = new_area;
2213
4681
                    idx = i;
2214
                }
2215
            }
2216
4922
            if (idx >= 0)
2217
4681
                new_video_stream(o, oc, idx);
2218
        }
2219
2220
        /* audio: most channels */
2221

5819
        if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2222
4927
            int best_score = 0, idx = -1;
2223
10030
            for (i = 0; i < nb_input_streams; i++) {
2224
                int score;
2225
5103
                ist = input_streams[i];
2226
5103
                score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2227
5103
                        + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2228
5103
                if (ist->user_set_discard == AVDISCARD_ALL)
2229
                    continue;
2230

5103
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2231
                    score > best_score) {
2232
1147
                    best_score = score;
2233
1147
                    idx = i;
2234
                }
2235
            }
2236
4927
            if (idx >= 0)
2237
1147
                new_audio_stream(o, oc, idx);
2238
        }
2239
2240
        /* subtitles: pick first */
2241

9203
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2242

5819
        if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2243
56
            for (i = 0; i < nb_input_streams; i++)
2244
48
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2245
                    AVCodecDescriptor const *input_descriptor =
2246
35
                        avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2247
35
                    AVCodecDescriptor const *output_descriptor = NULL;
2248
                    AVCodec const *output_codec =
2249
35
                        avcodec_find_encoder(oc->oformat->subtitle_codec);
2250
35
                    int input_props = 0, output_props = 0;
2251
35
                    if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2252
                        continue;
2253
35
                    if (output_codec)
2254
33
                        output_descriptor = avcodec_descriptor_get(output_codec->id);
2255
35
                    if (input_descriptor)
2256
35
                        input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2257
35
                    if (output_descriptor)
2258
33
                        output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2259
35
                    if (subtitle_codec_name ||
2260

28
                        input_props & output_props ||
2261
                        // Map dvb teletext which has neither property to any output subtitle encoder
2262
                        input_descriptor && output_descriptor &&
2263
                        (!input_descriptor->props ||
2264
                         !output_descriptor->props)) {
2265
35
                        new_subtitle_stream(o, oc, i);
2266
35
                        break;
2267
                    }
2268
                }
2269
        }
2270
        /* Data only if codec id match */
2271
5819
        if (!o->data_disable ) {
2272
5819
            enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2273

5819
            for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2274
                if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2275
                    continue;
2276
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2277
                    && input_streams[i]->st->codecpar->codec_id == codec_id )
2278
                    new_data_stream(o, oc, i);
2279
            }
2280
        }
2281
    } else {
2282
112
        for (i = 0; i < o->nb_stream_maps; i++) {
2283
69
            StreamMap *map = &o->stream_maps[i];
2284
2285
69
            if (map->disabled)
2286
                continue;
2287
2288
69
            if (map->linklabel) {
2289
                FilterGraph *fg;
2290
3
                OutputFilter *ofilter = NULL;
2291
                int j, k;
2292
2293
3
                for (j = 0; j < nb_filtergraphs; j++) {
2294
3
                    fg = filtergraphs[j];
2295
3
                    for (k = 0; k < fg->nb_outputs; k++) {
2296
3
                        AVFilterInOut *out = fg->outputs[k]->out_tmp;
2297

3
                        if (out && !strcmp(out->name, map->linklabel)) {
2298
3
                            ofilter = fg->outputs[k];
2299
3
                            goto loop_end;
2300
                        }
2301
                    }
2302
                }
2303
loop_end:
2304
3
                if (!ofilter) {
2305
                    av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2306
                           "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2307
                    exit_program(1);
2308
                }
2309
3
                init_output_filter(ofilter, o, oc);
2310
            } else {
2311
66
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2312
2313
66
                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2314
66
                if (ist->user_set_discard == AVDISCARD_ALL) {
2315
                    av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2316
                           map->file_index, map->stream_index);
2317
                    exit_program(1);
2318
                }
2319

66
                if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2320
                    continue;
2321

66
                if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2322
                    continue;
2323

66
                if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2324
                    continue;
2325

66
                if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2326
                    continue;
2327
2328
66
                ost = NULL;
2329

66
                switch (ist->st->codecpar->codec_type) {
2330
23
                case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2331
31
                case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2332
2
                case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2333
10
                case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2334
                case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2335
                case AVMEDIA_TYPE_UNKNOWN:
2336
                    if (copy_unknown_streams) {
2337
                        ost = new_unknown_stream   (o, oc, src_idx);
2338
                        break;
2339
                    }
2340
                default:
2341
                    av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2342
                           "Cannot map stream #%d:%d - unsupported type.\n",
2343
                           map->file_index, map->stream_index);
2344
                    if (!ignore_unknown_streams) {
2345
                        av_log(NULL, AV_LOG_FATAL,
2346
                               "If you want unsupported types ignored instead "
2347
                               "of failing, please use the -ignore_unknown option\n"
2348
                               "If you want them copied, please use -copy_unknown\n");
2349
                        exit_program(1);
2350
                    }
2351
                }
2352
66
                if (ost)
2353
66
                    ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2354
66
                                                  + map->sync_stream_index];
2355
            }
2356
        }
2357
    }
2358
2359
    /* handle attached files */
2360
5863
    for (i = 0; i < o->nb_attachments; i++) {
2361
        AVIOContext *pb;
2362
        uint8_t *attachment;
2363
        const char *p;
2364
        int64_t len;
2365
2366
1
        if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2367
            av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2368
                   o->attachments[i]);
2369
            exit_program(1);
2370
        }
2371
1
        if ((len = avio_size(pb)) <= 0) {
2372
            av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2373
                   o->attachments[i]);
2374
            exit_program(1);
2375
        }
2376
1
        if (!(attachment = av_malloc(len))) {
2377
            av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2378
                   o->attachments[i]);
2379
            exit_program(1);
2380
        }
2381
1
        avio_read(pb, attachment, len);
2382
2383
1
        ost = new_attachment_stream(o, oc, -1);
2384
1
        ost->stream_copy               = 0;
2385
1
        ost->attachment_filename       = o->attachments[i];
2386
1
        ost->st->codecpar->extradata      = attachment;
2387
1
        ost->st->codecpar->extradata_size = len;
2388
2389
1
        p = strrchr(o->attachments[i], '/');
2390

1
        av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2391
1
        avio_closep(&pb);
2392
    }
2393
2394
#if FF_API_LAVF_AVCTX
2395
11867
    for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2396
        AVDictionaryEntry *e;
2397
6005
        ost = output_streams[i];
2398
2399

6005
        if ((ost->stream_copy || ost->attachment_filename)
2400
290
            && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2401

62
            && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2402
62
            if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2403
                exit_program(1);
2404
    }
2405
#endif
2406
2407

5862
    if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2408
        av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2409
        av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2410
        exit_program(1);
2411
    }
2412
2413
    /* check if all codec options have been used */
2414
5862
    unused_opts = strip_specifiers(o->g->codec_opts);
2415
11867
    for (i = of->ost_index; i < nb_output_streams; i++) {
2416
6005
        e = NULL;
2417
19728
        while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2418
                                AV_DICT_IGNORE_SUFFIX)))
2419
13723
            av_dict_set(&unused_opts, e->key, NULL, 0);
2420
    }
2421
2422
5862
    e = NULL;
2423
6110
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2424
248
        const AVClass *class = avcodec_get_class();
2425
248
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2426
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2427
248
        const AVClass *fclass = avformat_get_class();
2428
248
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2429
                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2430

248
        if (!option || foption)
2431
9
            continue;
2432
2433
2434
247
        if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2435
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2436
                   "output file #%d (%s) is not an encoding option.\n", e->key,
2437
                   option->help ? option->help : "", nb_output_files - 1,
2438
                   filename);
2439
            exit_program(1);
2440
        }
2441
2442
        // gop_timecode is injected by generic code but not always used
2443
247
        if (!strcmp(e->key, "gop_timecode"))
2444
8
            continue;
2445
2446
239
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2447
               "output file #%d (%s) has not been used for any stream. The most "
2448
               "likely reason is either wrong type (e.g. a video option with "
2449
               "no video streams) or that it is a private option of some encoder "
2450
               "which was not actually used for any stream.\n", e->key,
2451
239
               option->help ? option->help : "", nb_output_files - 1, filename);
2452
    }
2453
5862
    av_dict_free(&unused_opts);
2454
2455
    /* set the decoding_needed flags and create simple filtergraphs */
2456
11867
    for (i = of->ost_index; i < nb_output_streams; i++) {
2457
6005
        OutputStream *ost = output_streams[i];
2458
2459

6005
        if (ost->encoding_needed && ost->source_index >= 0) {
2460
5640
            InputStream *ist = input_streams[ost->source_index];
2461
5640
            ist->decoding_needed |= DECODING_FOR_OST;
2462
2463
5640
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2464
1107
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2465
5610
                err = init_simple_filtergraph(ist, ost);
2466
5610
                if (err < 0) {
2467
                    av_log(NULL, AV_LOG_ERROR,
2468
                           "Error initializing a simple filtergraph between streams "
2469
                           "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2470
                           nb_output_files - 1, ost->st->index);
2471
                    exit_program(1);
2472
                }
2473
            }
2474
        }
2475
2476
        /* set the filter output constraints */
2477
6005
        if (ost->filter) {
2478
5685
            OutputFilter *f = ost->filter;
2479
            int count;
2480
5685
            switch (ost->enc_ctx->codec_type) {
2481
4593
            case AVMEDIA_TYPE_VIDEO:
2482
4593
                f->frame_rate = ost->frame_rate;
2483
4593
                f->width      = ost->enc_ctx->width;
2484
4593
                f->height     = ost->enc_ctx->height;
2485
4593
                if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2486
3296
                    f->format = ost->enc_ctx->pix_fmt;
2487
1297
                } else if (ost->enc->pix_fmts) {
2488
290
                    count = 0;
2489
1474
                    while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2490
1184
                        count++;
2491
290
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2492
290
                    if (!f->formats)
2493
                        exit_program(1);
2494
290
                    memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2495
                }
2496
4593
                break;
2497
1092
            case AVMEDIA_TYPE_AUDIO:
2498
1092
                if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2499
                    f->format = ost->enc_ctx->sample_fmt;
2500
1092
                } else if (ost->enc->sample_fmts) {
2501
1092
                    count = 0;
2502
2218
                    while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2503
1126
                        count++;
2504
1092
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2505
1092
                    if (!f->formats)
2506
                        exit_program(1);
2507
1092
                    memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2508
                }
2509
1092
                if (ost->enc_ctx->sample_rate) {
2510
25
                    f->sample_rate = ost->enc_ctx->sample_rate;
2511
1067
                } else if (ost->enc->supported_samplerates) {
2512
29
                    count = 0;
2513
281
                    while (ost->enc->supported_samplerates[count])
2514
252
                        count++;
2515
29
                    f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2516
29
                    if (!f->sample_rates)
2517
                        exit_program(1);
2518
29
                    memcpy(f->sample_rates, ost->enc->supported_samplerates,
2519
29
                           (count + 1) * sizeof(*f->sample_rates));
2520
                }
2521
1092
                if (ost->enc_ctx->channels) {
2522
12
                    f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2523
1080
                } else if (ost->enc->channel_layouts) {
2524
42
                    count = 0;
2525
280
                    while (ost->enc->channel_layouts[count])
2526
238
                        count++;
2527
42
                    f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2528
42
                    if (!f->channel_layouts)
2529
                        exit_program(1);
2530
42
                    memcpy(f->channel_layouts, ost->enc->channel_layouts,
2531
42
                           (count + 1) * sizeof(*f->channel_layouts));
2532
                }
2533
1092
                break;
2534
            }
2535
6005
        }
2536
    }
2537
2538
    /* check filename in case of an image number is expected */
2539
5862
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2540
        if (!av_filename_number_test(oc->url)) {
2541
            print_error(oc->url, AVERROR(EINVAL));
2542
            exit_program(1);
2543
        }
2544
    }
2545
2546

5862
    if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2547
        av_log(NULL, AV_LOG_ERROR,
2548
               "No input streams but output needs an input stream\n");
2549
        exit_program(1);
2550
    }
2551
2552
5862
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2553
        /* test if it already exists to avoid losing precious files */
2554
5809
        assert_file_overwrite(filename);
2555
2556
        /* open the file */
2557
5809
        if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2558
5809
                              &oc->interrupt_callback,
2559
                              &of->opts)) < 0) {
2560
            print_error(filename, err);
2561
            exit_program(1);
2562
        }
2563

53
    } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2564
        assert_file_overwrite(filename);
2565
2566
5862
    if (o->mux_preload) {
2567
        av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2568
    }
2569
5862
    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2570
2571
    /* copy metadata */
2572
5867
    for (i = 0; i < o->nb_metadata_map; i++) {
2573
        char *p;
2574
5
        int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2575
2576
5
        if (in_file_index >= nb_input_files) {
2577
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2578
            exit_program(1);
2579
        }
2580

8
        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2581
                      in_file_index >= 0 ?
2582
3
                      input_files[in_file_index]->ctx : NULL, o);
2583
    }
2584
2585
    /* copy chapters */
2586
5862
    if (o->chapters_input_file >= nb_input_files) {
2587
5862
        if (o->chapters_input_file == INT_MAX) {
2588
            /* copy chapters from the first input file that has them*/
2589
5862
            o->chapters_input_file = -1;
2590
11746
            for (i = 0; i < nb_input_files; i++)
2591
5894
                if (input_files[i]->ctx->nb_chapters) {
2592
10
                    o->chapters_input_file = i;
2593
10
                    break;
2594
                }
2595
        } else {
2596
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2597
                   o->chapters_input_file);
2598
            exit_program(1);
2599
        }
2600
    }
2601
5862
    if (o->chapters_input_file >= 0)
2602
10
        copy_chapters(input_files[o->chapters_input_file], of,
2603
10
                      !o->metadata_chapters_manual);
2604
2605
    /* copy global metadata by default */
2606

5862
    if (!o->metadata_global_manual && nb_input_files){
2607
5822
        av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2608
                     AV_DICT_DONT_OVERWRITE);
2609
5822
        if(o->recording_time != INT64_MAX)
2610
121
            av_dict_set(&oc->metadata, "duration", NULL, 0);
2611
5822
        av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2612
    }
2613
5862
    if (!o->metadata_streams_manual)
2614
11863
        for (i = of->ost_index; i < nb_output_streams; i++) {
2615
            InputStream *ist;
2616
6002
            if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2617
76
                continue;
2618
5926
            ist = input_streams[output_streams[i]->source_index];
2619
5926
            av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2620
5926
            if (!output_streams[i]->stream_copy) {
2621
5637
                av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2622
            }
2623
        }
2624
2625
    /* process manually set programs */
2626
5862
    for (i = 0; i < o->nb_program; i++) {
2627
        const char *p = o->program[i].u.str;
2628
        int progid = i+1;
2629
        AVProgram *program;
2630
2631
        while(*p) {
2632
            const char *p2 = av_get_token(&p, ":");
2633
            const char *to_dealloc = p2;
2634
            char *key;
2635
            if (!p2)
2636
                break;
2637
2638
            if(*p) p++;
2639
2640
            key = av_get_token(&p2, "=");
2641
            if (!key || !*p2) {
2642
                av_freep(&to_dealloc);
2643
                av_freep(&key);
2644
                break;
2645
            }
2646
            p2++;
2647
2648
            if (!strcmp(key, "program_num"))
2649
                progid = strtol(p2, NULL, 0);
2650
            av_freep(&to_dealloc);
2651
            av_freep(&key);
2652
        }
2653
2654
        program = av_new_program(oc, progid);
2655
2656
        p = o->program[i].u.str;
2657
        while(*p) {
2658
            const char *p2 = av_get_token(&p, ":");
2659
            const char *to_dealloc = p2;
2660
            char *key;
2661
            if (!p2)
2662
                break;
2663
            if(*p) p++;
2664
2665
            key = av_get_token(&p2, "=");
2666
            if (!key) {
2667
                av_log(NULL, AV_LOG_FATAL,
2668
                       "No '=' character in program string %s.\n",
2669
                       p2);
2670
                exit_program(1);
2671
            }
2672
            if (!*p2)
2673
                exit_program(1);
2674
            p2++;
2675
2676
            if (!strcmp(key, "title")) {
2677
                av_dict_set(&program->metadata, "title", p2, 0);
2678
            } else if (!strcmp(key, "program_num")) {
2679
            } else if (!strcmp(key, "st")) {
2680
                int st_num = strtol(p2, NULL, 0);
2681
                av_program_add_stream_index(oc, progid, st_num);
2682
            } else {
2683
                av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2684
                exit_program(1);
2685
            }
2686
            av_freep(&to_dealloc);
2687
            av_freep(&key);
2688
        }
2689
    }
2690
2691
    /* process manually set metadata */
2692
6004
    for (i = 0; i < o->nb_metadata; i++) {
2693
        AVDictionary **m;
2694
        char type, *val;
2695
        const char *stream_spec;
2696
142
        int index = 0, j, ret = 0;
2697
2698
142
        val = strchr(o->metadata[i].u.str, '=');
2699
142
        if (!val) {
2700
            av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2701
                   o->metadata[i].u.str);
2702
            exit_program(1);
2703
        }
2704
142
        *val++ = 0;
2705
2706
142
        parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2707
142
        if (type == 's') {
2708
19
            for (j = 0; j < oc->nb_streams; j++) {
2709
11
                ost = output_streams[nb_output_streams - oc->nb_streams + j];
2710
11
                if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2711
8
                    if (!strcmp(o->metadata[i].u.str, "rotate")) {
2712
                        char *tail;
2713
1
                        double theta = av_strtod(val, &tail);
2714
1
                        if (!*tail) {
2715
1
                            ost->rotate_overridden = 1;
2716
1
                            ost->rotate_override_value = theta;
2717
                        }
2718
                    } else {
2719
7
                        av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2720
                    }
2721
3
                } else if (ret < 0)
2722
                    exit_program(1);
2723
            }
2724
        }
2725
        else {
2726

134
            switch (type) {
2727
134
            case 'g':
2728
134
                m = &oc->metadata;
2729
134
                break;
2730
            case 'c':
2731
                if (index < 0 || index >= oc->nb_chapters) {
2732
                    av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2733
                    exit_program(1);
2734
                }
2735
                m = &oc->chapters[index]->metadata;
2736
                break;
2737
            case 'p':
2738
                if (index < 0 || index >= oc->nb_programs) {
2739
                    av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2740
                    exit_program(1);
2741
                }
2742
                m = &oc->programs[index]->metadata;
2743
                break;
2744
            default:
2745
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2746
                exit_program(1);
2747
            }
2748
134
            av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2749
        }
2750
    }
2751
2752
5862
    return 0;
2753
}
2754
2755
static int opt_target(void *optctx, const char *opt, const char *arg)
2756
{
2757
    OptionsContext *o = optctx;
2758
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2759
    static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2760
2761
    if (!strncmp(arg, "pal-", 4)) {
2762
        norm = PAL;
2763
        arg += 4;
2764
    } else if (!strncmp(arg, "ntsc-", 5)) {
2765
        norm = NTSC;
2766
        arg += 5;
2767
    } else if (!strncmp(arg, "film-", 5)) {
2768
        norm = FILM;
2769
        arg += 5;
2770
    } else {
2771
        /* Try to determine PAL/NTSC by peeking in the input files */
2772
        if (nb_input_files) {
2773
            int i, j;
2774
            for (j = 0; j < nb_input_files; j++) {
2775
                for (i = 0; i < input_files[j]->nb_streams; i++) {
2776
                    AVStream *st = input_files[j]->ctx->streams[i];
2777
                    int64_t fr;
2778
                    if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2779
                        continue;
2780
                    fr = st->time_base.den * 1000LL / st->time_base.num;
2781
                    if (fr == 25000) {
2782
                        norm = PAL;
2783
                        break;
2784
                    } else if ((fr == 29970) || (fr == 23976)) {
2785
                        norm = NTSC;
2786
                        break;
2787
                    }
2788
                }
2789
                if (norm != UNKNOWN)
2790
                    break;
2791
            }
2792
        }
2793
        if (norm != UNKNOWN)
2794
            av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2795
    }
2796
2797
    if (norm == UNKNOWN) {
2798
        av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2799
        av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2800
        av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2801
        exit_program(1);
2802
    }
2803
2804
    if (!strcmp(arg, "vcd")) {
2805
        opt_video_codec(o, "c:v", "mpeg1video");
2806
        opt_audio_codec(o, "c:a", "mp2");
2807
        parse_option(o, "f", "vcd", options);
2808
2809
        parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2810
        parse_option(o, "r", frame_rates[norm], options);
2811
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2812
2813
        opt_default(NULL, "b:v", "1150000");
2814
        opt_default(NULL, "maxrate:v", "1150000");
2815
        opt_default(NULL, "minrate:v", "1150000");
2816
        opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2817
2818
        opt_default(NULL, "b:a", "224000");
2819
        parse_option(o, "ar", "44100", options);
2820
        parse_option(o, "ac", "2", options);
2821
2822
        opt_default(NULL, "packetsize", "2324");
2823
        opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2824
2825
        /* We have to offset the PTS, so that it is consistent with the SCR.
2826
           SCR starts at 36000, but the first two packs contain only padding
2827
           and the first pack from the other stream, respectively, may also have
2828
           been written before.
2829
           So the real data starts at SCR 36000+3*1200. */
2830
        o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2831
    } else if (!strcmp(arg, "svcd")) {
2832
2833
        opt_video_codec(o, "c:v", "mpeg2video");
2834
        opt_audio_codec(o, "c:a", "mp2");
2835
        parse_option(o, "f", "svcd", options);
2836
2837
        parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2838
        parse_option(o, "r", frame_rates[norm], options);
2839
        parse_option(o, "pix_fmt", "yuv420p", options);
2840
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2841
2842
        opt_default(NULL, "b:v", "2040000");
2843
        opt_default(NULL, "maxrate:v", "2516000");
2844
        opt_default(NULL, "minrate:v", "0"); // 1145000;
2845
        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2846
        opt_default(NULL, "scan_offset", "1");
2847
2848
        opt_default(NULL, "b:a", "224000");
2849
        parse_option(o, "ar", "44100", options);
2850
2851
        opt_default(NULL, "packetsize", "2324");
2852
2853
    } else if (!strcmp(arg, "dvd")) {
2854
2855
        opt_video_codec(o, "c:v", "mpeg2video");
2856
        opt_audio_codec(o, "c:a", "ac3");
2857
        parse_option(o, "f", "dvd", options);
2858
2859
        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2860
        parse_option(o, "r", frame_rates[norm], options);
2861
        parse_option(o, "pix_fmt", "yuv420p", options);
2862
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2863
2864
        opt_default(NULL, "b:v", "6000000");
2865
        opt_default(NULL, "maxrate:v", "9000000");
2866
        opt_default(NULL, "minrate:v", "0"); // 1500000;
2867
        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2868
2869
        opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2870
        opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2871
2872
        opt_default(NULL, "b:a", "448000");
2873
        parse_option(o, "ar", "48000", options);
2874
2875
    } else if (!strncmp(arg, "dv", 2)) {
2876
2877
        parse_option(o, "f", "dv", options);
2878
2879
        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2880
        parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2881
                          norm == PAL ? "yuv420p" : "yuv411p", options);
2882
        parse_option(o, "r", frame_rates[norm], options);
2883
2884
        parse_option(o, "ar", "48000", options);
2885
        parse_option(o, "ac", "2", options);
2886
2887
    } else {
2888
        av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2889
        return AVERROR(EINVAL);
2890
    }
2891
2892
    av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2893
    av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2894
2895
    return 0;
2896
}
2897
2898
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2899
{
2900
    av_free (vstats_filename);
2901
    vstats_filename = av_strdup (arg);
2902
    return 0;
2903
}
2904
2905
static int opt_vstats(void *optctx, const char *opt, const char *arg)
2906
{
2907
    char filename[40];
2908
    time_t today2 = time(NULL);
2909
    struct tm *today = localtime(&today2);
2910
2911
    if (!today) { // maybe tomorrow
2912
        av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2913
        exit_program(1);
2914
    }
2915
2916
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2917
             today->tm_sec);
2918
    return opt_vstats_file(NULL, opt, filename);
2919
}
2920
2921
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2922
{
2923
    OptionsContext *o = optctx;
2924
    return parse_option(o, "frames:v", arg, options);
2925
}
2926
2927
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2928
{
2929
    OptionsContext *o = optctx;
2930
    return parse_option(o, "frames:a", arg, options);
2931
}
2932
2933
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2934
{
2935
    OptionsContext *o = optctx;
2936
    return parse_option(o, "frames:d", arg, options);
2937
}
2938
2939
2
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2940
{
2941
    int ret;
2942
2
    AVDictionary *cbak = codec_opts;
2943
2
    AVDictionary *fbak = format_opts;
2944
2
    codec_opts = NULL;
2945
2
    format_opts = NULL;
2946
2947
2
    ret = opt_default(NULL, opt, arg);
2948
2949
2
    av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2950
2
    av_dict_copy(&o->g->format_opts, format_opts, 0);
2951
2
    av_dict_free(&codec_opts);
2952
2
    av_dict_free(&format_opts);
2953
2
    codec_opts = cbak;
2954
2
    format_opts = fbak;
2955
2956
2
    return ret;
2957
}
2958
2959
static int opt_preset(void *optctx, const char *opt, const char *arg)
2960
{
2961
    OptionsContext *o = optctx;
2962
    FILE *f=NULL;
2963
    char filename[1000], line[1000], tmp_line[1000];
2964
    const char *codec_name = NULL;
2965
2966
    tmp_line[0] = *opt;
2967
    tmp_line[1] = 0;
2968
    MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2969
2970
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2971
        if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2972
            av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2973
        }else
2974
            av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2975
        exit_program(1);
2976
    }
2977
2978
    while (fgets(line, sizeof(line), f)) {
2979
        char *key = tmp_line, *value, *endptr;
2980
2981
        if (strcspn(line, "#\n\r") == 0)
2982
            continue;
2983
        av_strlcpy(tmp_line, line, sizeof(tmp_line));
2984
        if (!av_strtok(key,   "=",    &value) ||
2985
            !av_strtok(value, "\r\n", &endptr)) {
2986
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2987
            exit_program(1);
2988
        }
2989
        av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2990
2991
        if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2992
        else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2993
        else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2994
        else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2995
        else if (opt_default_new(o, key, value) < 0) {
2996
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2997
                   filename, line, key, value);
2998
            exit_program(1);
2999
        }
3000
    }
3001
3002
    fclose(f);
3003
3004
    return 0;
3005
}
3006
3007
3
static int opt_old2new(void *optctx, const char *opt, const char *arg)
3008
{
3009
3
    OptionsContext *o = optctx;
3010
    int ret;
3011
3
    char *s = av_asprintf("%s:%c", opt + 1, *opt);
3012
3
    if (!s)
3013
        return AVERROR(ENOMEM);
3014
3
    ret = parse_option(o, s, arg, options);
3015
3
    av_free(s);
3016
3
    return ret;
3017
}
3018
3019
153
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3020
{
3021
153
    OptionsContext *o = optctx;
3022
3023
153
    if(!strcmp(opt, "ab")){
3024
1
        av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3025
1
        return 0;
3026
152
    } else if(!strcmp(opt, "b")){
3027
39
        av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3028
39
        av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3029
39
        return 0;
3030
    }
3031
113
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
3032
113
    return 0;
3033
}
3034
3035
254
static int opt_qscale(void *optctx, const char *opt, const char *arg)
3036
{
3037
254
    OptionsContext *o = optctx;
3038
    char *s;
3039
    int ret;
3040
254
    if(!strcmp(opt, "qscale")){
3041
215
        av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3042
215
        return parse_option(o, "q:v", arg, options);
3043
    }
3044
39
    s = av_asprintf("q%s", opt + 6);
3045
39
    if (!s)
3046
        return AVERROR(ENOMEM);
3047
39
    ret = parse_option(o, s, arg, options);
3048
39
    av_free(s);
3049
39
    return ret;
3050
}
3051
3052
45
static int opt_profile(void *optctx, const char *opt, const char *arg)
3053
{
3054
45
    OptionsContext *o = optctx;
3055
45
    if(!strcmp(opt, "profile")){
3056
4
        av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3057
4
        av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3058
4
        return 0;
3059
    }
3060
41
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
3061
41
    return 0;
3062
}
3063
3064
2171
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3065
{
3066
2171
    OptionsContext *o = optctx;
3067
2171
    return parse_option(o, "filter:v", arg, options);
3068
}
3069
3070
380
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3071
{
3072
380
    OptionsContext *o = optctx;
3073
380
    return parse_option(o, "filter:a", arg, options);
3074
}
3075
3076
801
static int opt_vsync(void *optctx, const char *opt, const char *arg)
3077
{
3078
801
    if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3079
797
    else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3080
796
    else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3081
795
    else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3082
3083
801
    if (video_sync_method == VSYNC_AUTO)
3084
473
        video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3085
801
    return 0;
3086
}
3087
3088
15
static int opt_timecode(void *optctx, const char *opt, const char *arg)
3089
{
3090
15
    OptionsContext *o = optctx;
3091
    int ret;
3092
15
    char *tcr = av_asprintf("timecode=%s", arg);
3093
15
    if (!tcr)
3094
        return AVERROR(ENOMEM);
3095
15
    ret = parse_option(o, "metadata:g", tcr, options);
3096
15
    if (ret >= 0)
3097
15
        ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3098
15
    av_free(tcr);
3099
15
    return ret;
3100
}
3101
3102
2
static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3103
{
3104
2
    OptionsContext *o = optctx;
3105
    char layout_str[32];
3106
    char *stream_str;
3107
    char *ac_str;
3108
    int ret, channels, ac_str_size;
3109
    uint64_t layout;
3110
3111
2
    layout = av_get_channel_layout(arg);
3112
2
    if (!layout) {
3113
        av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3114
        return AVERROR(EINVAL);
3115
    }
3116
2
    snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3117
2
    ret = opt_default_new(o, opt, layout_str);
3118
2
    if (ret < 0)
3119
        return ret;
3120
3121
    /* set 'ac' option based on channel layout */
3122
2
    channels = av_get_channel_layout_nb_channels(layout);
3123
2
    snprintf(layout_str, sizeof(layout_str), "%d", channels);
3124
2
    stream_str = strchr(opt, ':');
3125
2
    ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3126
2
    ac_str = av_mallocz(ac_str_size);
3127
2
    if (!ac_str)
3128
        return AVERROR(ENOMEM);
3129
2
    av_strlcpy(ac_str, "ac", 3);
3130
2
    if (stream_str)
3131
        av_strlcat(ac_str, stream_str, ac_str_size);
3132
2
    ret = parse_option(o, ac_str, layout_str, options);
3133
2
    av_free(ac_str);
3134
3135
2
    return ret;
3136
}
3137
3138
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3139
{
3140
    OptionsContext *o = optctx;
3141
    return parse_option(o, "q:a", arg, options);
3142
}
3143
3144
50
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3145
{
3146
50
    GROW_ARRAY(filtergraphs, nb_filtergraphs);
3147
50
    if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3148
        return AVERROR(ENOMEM);
3149
50
    filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3150
50
    filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3151
50
    if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3152
        return AVERROR(ENOMEM);
3153
3154
50
    input_stream_potentially_available = 1;
3155
3156
50
    return 0;
3157
}
3158
3159
22
static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3160
{
3161
22
    uint8_t *graph_desc = read_file(arg);
3162
22
    if (!graph_desc)
3163
        return AVERROR(EINVAL);
3164
3165
22
    GROW_ARRAY(filtergraphs, nb_filtergraphs);
3166
22
    if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3167
        return AVERROR(ENOMEM);
3168
22
    filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3169
22
    filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3170
3171
22
    input_stream_potentially_available = 1;
3172
3173
22
    return 0;
3174
}
3175
3176
void show_help_default(const char *opt, const char *arg)
3177
{
3178
    /* per-file options have at least one of those set */
3179
    const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3180
    int show_advanced = 0, show_avoptions = 0;
3181
3182
    if (opt && *opt) {
3183
        if (!strcmp(opt, "long"))
3184
            show_advanced = 1;
3185
        else if (!strcmp(opt, "full"))
3186
            show_advanced = show_avoptions = 1;
3187
        else
3188
            av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3189
    }
3190
3191
    show_usage();
3192
3193
    printf("Getting help:\n"
3194
           "    -h      -- print basic options\n"
3195
           "    -h long -- print more options\n"
3196
           "    -h full -- print all options (including all format and codec specific options, very long)\n"
3197
           "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3198
           "    See man %s for detailed description of the options.\n"
3199
           "\n", program_name);
3200
3201
    show_help_options(options, "Print help / information / capabilities:",
3202
                      OPT_EXIT, 0, 0);
3203
3204
    show_help_options(options, "Global options (affect whole program "
3205
                      "instead of just one file):",
3206
                      0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3207
    if (show_advanced)
3208
        show_help_options(options, "Advanced global options:", OPT_EXPERT,
3209
                          per_file | OPT_EXIT, 0);
3210
3211
    show_help_options(options, "Per-file main options:", 0,
3212
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3213
                      OPT_EXIT, per_file);
3214
    if (show_advanced)
3215
        show_help_options(options, "Advanced per-file options:",
3216
                          OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3217
3218
    show_help_options(options, "Video options:",
3219
                      OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3220
    if (show_advanced)
3221
        show_help_options(options, "Advanced Video options:",
3222
                          OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3223
3224
    show_help_options(options, "Audio options:",
3225
                      OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3226
    if (show_advanced)
3227
        show_help_options(options, "Advanced Audio options:",
3228
                          OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3229
    show_help_options(options, "Subtitle options:",
3230
                      OPT_SUBTITLE, 0, 0);
3231
    printf("\n");
3232
3233
    if (show_avoptions) {
3234
        int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3235
        show_help_children(avcodec_get_class(), flags);
3236
        show_help_children(avformat_get_class(), flags);
3237
#if CONFIG_SWSCALE
3238
        show_help_children(sws_get_class(), flags);
3239
#endif
3240
#if CONFIG_SWRESAMPLE
3241
        show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3242
#endif
3243
        show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3244
        show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3245
    }
3246
}
3247
3248
void show_usage(void)
3249
{
3250
    av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3251
    av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3252
    av_log(NULL, AV_LOG_INFO, "\n");
3253
}
3254
3255
enum OptGroup {
3256
    GROUP_OUTFILE,
3257
    GROUP_INFILE,
3258
};
3259
3260
static const OptionGroupDef groups[] = {
3261
    [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
3262
    [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
3263
};
3264
3265
11723
static int open_files(OptionGroupList *l, const char *inout,
3266
                      int (*open_file)(OptionsContext*, const char*))
3267
{
3268
    int i, ret;
3269
3270
23478
    for (i = 0; i < l->nb_groups; i++) {
3271
11756
        OptionGroup *g = &l->groups[i];
3272
        OptionsContext o;
3273
3274
11756
        init_options(&o);
3275
11756
        o.g = g;
3276
3277
11756
        ret = parse_optgroup(&o, g);
3278
11756
        if (ret < 0) {
3279
            av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3280
                   "%s.\n", inout, g->arg);
3281
            return ret;
3282
        }
3283
3284
11756
        av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3285
11756
        ret = open_file(&o, g->arg);
3286
11755
        uninit_options(&o);
3287
11755
        if (ret < 0) {
3288
            av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3289
                   inout, g->arg);
3290
            return ret;
3291
        }
3292
11755
        av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3293
    }
3294
3295
11722
    return 0;
3296
}
3297
3298
5863
int ffmpeg_parse_options(int argc, char **argv)
3299
{
3300
    OptionParseContext octx;
3301
    uint8_t error[128];
3302
    int ret;
3303
3304
5863
    memset(&octx, 0, sizeof(octx));
3305
3306
    /* split the commandline into an internal representation */
3307
5863
    ret = split_commandline(&octx, argc, argv, options, groups,
3308
                            FF_ARRAY_ELEMS(groups));
3309
5863
    if (ret < 0) {
3310
        av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3311
        goto fail;
3312
    }
3313
3314
    /* apply global options */
3315
5863
    ret = parse_optgroup(NULL, &octx.global_opts);
3316
5862
    if (ret < 0) {
3317
        av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3318
        goto fail;
3319
    }
3320
3321
</