GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/bsf.c Lines: 89 286 31.1 %
Date: 2020-04-02 05:41:20 Branches: 49 162 30.2 %

Line Branch Exec Source
1
/*
2
 * This file is part of FFmpeg.
3
 *
4
 * FFmpeg is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * FFmpeg is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with FFmpeg; if not, write to the Free Software
16
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
 */
18
19
#include <string.h>
20
21
#include "libavutil/log.h"
22
#include "libavutil/mem.h"
23
#include "libavutil/opt.h"
24
#include "libavutil/avstring.h"
25
#include "libavutil/bprint.h"
26
27
#include "avcodec.h"
28
#include "bsf.h"
29
30
struct AVBSFInternal {
31
    AVPacket *buffer_pkt;
32
    int eof;
33
};
34
35
31884
void av_bsf_free(AVBSFContext **pctx)
36
{
37
    AVBSFContext *ctx;
38
39

31884
    if (!pctx || !*pctx)
40
18699
        return;
41
13185
    ctx = *pctx;
42
43
13185
    if (ctx->filter->close)
44
1225
        ctx->filter->close(ctx);
45

13185
    if (ctx->filter->priv_class && ctx->priv_data)
46
748
        av_opt_free(ctx->priv_data);
47
48
13185
    if (ctx->internal)
49
13185
        av_packet_free(&ctx->internal->buffer_pkt);
50
13185
    av_freep(&ctx->internal);
51
13185
    av_freep(&ctx->priv_data);
52
53
13185
    avcodec_parameters_free(&ctx->par_in);
54
13185
    avcodec_parameters_free(&ctx->par_out);
55
56
13185
    av_freep(pctx);
57
}
58
59
static void *bsf_child_next(void *obj, void *prev)
60
{
61
    AVBSFContext *ctx = obj;
62
    if (!prev && ctx->filter->priv_class)
63
        return ctx->priv_data;
64
    return NULL;
65
}
66
67
static const char *bsf_to_name(void *bsf)
68
{
69
    return ((AVBSFContext *)bsf)->filter->name;
70
}
71
72
static const AVClass bsf_class = {
73
    .class_name       = "AVBSFContext",
74
    .item_name        = bsf_to_name,
75
    .version          = LIBAVUTIL_VERSION_INT,
76
    .child_next       = bsf_child_next,
77
    .child_class_next = ff_bsf_child_class_next,
78
    .category         = AV_CLASS_CATEGORY_BITSTREAM_FILTER,
79
};
80
81
const AVClass *av_bsf_get_class(void)
82
{
83
    return &bsf_class;
84
}
85
86
13185
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
87
{
88
    AVBSFContext *ctx;
89
    AVBSFInternal *bsfi;
90
    int ret;
91
92
13185
    ctx = av_mallocz(sizeof(*ctx));
93
13185
    if (!ctx)
94
        return AVERROR(ENOMEM);
95
96
13185
    ctx->av_class = &bsf_class;
97
13185
    ctx->filter   = filter;
98
99
13185
    ctx->par_in  = avcodec_parameters_alloc();
100
13185
    ctx->par_out = avcodec_parameters_alloc();
101

13185
    if (!ctx->par_in || !ctx->par_out) {
102
        ret = AVERROR(ENOMEM);
103
        goto fail;
104
    }
105
106
13185
    bsfi = av_mallocz(sizeof(*bsfi));
107
13185
    if (!bsfi) {
108
        ret = AVERROR(ENOMEM);
109
        goto fail;
110
    }
111
13185
    ctx->internal = bsfi;
112
113
13185
    bsfi->buffer_pkt = av_packet_alloc();
114
13185
    if (!bsfi->buffer_pkt) {
115
        ret = AVERROR(ENOMEM);
116
        goto fail;
117
    }
118
119
    /* allocate priv data and init private options */
120
13185
    if (filter->priv_data_size) {
121
1240
        ctx->priv_data = av_mallocz(filter->priv_data_size);
122
1240
        if (!ctx->priv_data) {
123
            ret = AVERROR(ENOMEM);
124
            goto fail;
125
        }
126
1240
        if (filter->priv_class) {
127
748
            *(const AVClass **)ctx->priv_data = filter->priv_class;
128
748
            av_opt_set_defaults(ctx->priv_data);
129
        }
130
    }
131
132
13185
    *pctx = ctx;
133
13185
    return 0;
134
fail:
135
    av_bsf_free(&ctx);
136
    return ret;
137
}
138
139
13185
int av_bsf_init(AVBSFContext *ctx)
140
{
141
    int ret, i;
142
143
    /* check that the codec is supported */
144
13185
    if (ctx->filter->codec_ids) {
145
4161
        for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++)
146
4161
            if (ctx->par_in->codec_id == ctx->filter->codec_ids[i])
147
1239
                break;
148
1239
        if (ctx->filter->codec_ids[i] == AV_CODEC_ID_NONE) {
149
            const AVCodecDescriptor *desc = avcodec_descriptor_get(ctx->par_in->codec_id);
150
            av_log(ctx, AV_LOG_ERROR, "Codec '%s' (%d) is not supported by the "
151
                   "bitstream filter '%s'. Supported codecs are: ",
152
                   desc ? desc->name : "unknown", ctx->par_in->codec_id, ctx->filter->name);
153
            for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) {
154
                desc = avcodec_descriptor_get(ctx->filter->codec_ids[i]);
155
                av_log(ctx, AV_LOG_ERROR, "%s (%d) ",
156
                       desc ? desc->name : "unknown", ctx->filter->codec_ids[i]);
157
            }
158
            av_log(ctx, AV_LOG_ERROR, "\n");
159
            return AVERROR(EINVAL);
160
        }
161
    }
162
163
    /* initialize output parameters to be the same as input
164
     * init below might overwrite that */
165
13185
    ret = avcodec_parameters_copy(ctx->par_out, ctx->par_in);
166
13185
    if (ret < 0)
167
        return ret;
168
169
13185
    ctx->time_base_out = ctx->time_base_in;
170
171
13185
    if (ctx->filter->init) {
172
1234
        ret = ctx->filter->init(ctx);
173
1234
        if (ret < 0)
174
            return ret;
175
    }
176
177
13185
    return 0;
178
}
179
180
28
void av_bsf_flush(AVBSFContext *ctx)
181
{
182
28
    AVBSFInternal *bsfi = ctx->internal;
183
184
28
    bsfi->eof = 0;
185
186
28
    av_packet_unref(bsfi->buffer_pkt);
187
188
28
    if (ctx->filter->flush)
189
        ctx->filter->flush(ctx);
190
28
}
191
192
422147
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
193
{
194
422147
    AVBSFInternal *bsfi = ctx->internal;
195
    int ret;
196
197

422147
    if (!pkt || (!pkt->data && !pkt->side_data_elems)) {
198
5752
        bsfi->eof = 1;
199
5752
        return 0;
200
    }
201
202
416395
    if (bsfi->eof) {
203
        av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");
204
        return AVERROR(EINVAL);
205
    }
206
207
416395
    if (bsfi->buffer_pkt->data ||
208
416395
        bsfi->buffer_pkt->side_data_elems)
209
        return AVERROR(EAGAIN);
210
211
416395
    ret = av_packet_make_refcounted(pkt);
212
416395
    if (ret < 0)
213
        return ret;
214
416395
    av_packet_move_ref(bsfi->buffer_pkt, pkt);
215
216
416395
    return 0;
217
}
218
219
837764
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
220
{
221
837764
    return ctx->filter->filter(ctx, pkt);
222
}
223
224
578
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
225
{
226
578
    AVBSFInternal *bsfi = ctx->internal;
227
    AVPacket *tmp_pkt;
228
229
578
    if (bsfi->eof)
230
        return AVERROR_EOF;
231
232
578
    if (!bsfi->buffer_pkt->data &&
233
132
        !bsfi->buffer_pkt->side_data_elems)
234
132
        return AVERROR(EAGAIN);
235
236
446
    tmp_pkt = av_packet_alloc();
237
446
    if (!tmp_pkt)
238
        return AVERROR(ENOMEM);
239
240
446
    *pkt = bsfi->buffer_pkt;
241
446
    bsfi->buffer_pkt = tmp_pkt;
242
243
446
    return 0;
244
}
245
246
837124
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
247
{
248
837124
    AVBSFInternal *bsfi = ctx->internal;
249
250
837124
    if (bsfi->eof)
251
5752
        return AVERROR_EOF;
252
253
831372
    if (!bsfi->buffer_pkt->data &&
254
415423
        !bsfi->buffer_pkt->side_data_elems)
255
415423
        return AVERROR(EAGAIN);
256
257
415949
    av_packet_move_ref(pkt, bsfi->buffer_pkt);
258
259
415949
    return 0;
260
}
261
262
typedef struct BSFListContext {
263
    const AVClass *class;
264
265
    AVBSFContext **bsfs;
266
    int nb_bsfs;
267
268
    unsigned idx;           // index of currently processed BSF
269
    unsigned flushed_idx;   // index of BSF being flushed
270
271
    char * item_name;
272
} BSFListContext;
273
274
275
static int bsf_list_init(AVBSFContext *bsf)
276
{
277
    BSFListContext *lst = bsf->priv_data;
278
    int ret, i;
279
    const AVCodecParameters *cod_par = bsf->par_in;
280
    AVRational tb = bsf->time_base_in;
281
282
    for (i = 0; i < lst->nb_bsfs; ++i) {
283
        ret = avcodec_parameters_copy(lst->bsfs[i]->par_in, cod_par);
284
        if (ret < 0)
285
            goto fail;
286
287
        lst->bsfs[i]->time_base_in = tb;
288
289
        ret = av_bsf_init(lst->bsfs[i]);
290
        if (ret < 0)
291
            goto fail;
292
293
        cod_par = lst->bsfs[i]->par_out;
294
        tb = lst->bsfs[i]->time_base_out;
295
    }
296
297
    bsf->time_base_out = tb;
298
    ret = avcodec_parameters_copy(bsf->par_out, cod_par);
299
300
fail:
301
    return ret;
302
}
303
304
static int bsf_list_filter(AVBSFContext *bsf, AVPacket *out)
305
{
306
    BSFListContext *lst = bsf->priv_data;
307
    int ret;
308
309
    if (!lst->nb_bsfs)
310
        return ff_bsf_get_packet_ref(bsf, out);
311
312
    while (1) {
313
        if (lst->idx > lst->flushed_idx) {
314
            ret = av_bsf_receive_packet(lst->bsfs[lst->idx-1], out);
315
            if (ret == AVERROR(EAGAIN)) {
316
                /* no more packets from idx-1, try with previous */
317
                lst->idx--;
318
                continue;
319
            } else if (ret == AVERROR_EOF) {
320
                /* filter idx-1 is done, continue with idx...nb_bsfs */
321
                lst->flushed_idx = lst->idx;
322
                continue;
323
            }else if (ret < 0) {
324
                /* filtering error */
325
                break;
326
            }
327
        } else {
328
            ret = ff_bsf_get_packet_ref(bsf, out);
329
            if (ret == AVERROR_EOF) {
330
                lst->idx = lst->flushed_idx;
331
            } else if (ret < 0)
332
                break;
333
        }
334
335
        if (lst->idx < lst->nb_bsfs) {
336
            AVPacket *pkt;
337
            if (ret == AVERROR_EOF && lst->idx == lst->flushed_idx) {
338
                /* ff_bsf_get_packet_ref returned EOF and idx is first
339
                 * filter of yet not flushed filter chain */
340
                pkt = NULL;
341
            } else {
342
                pkt = out;
343
            }
344
            ret = av_bsf_send_packet(lst->bsfs[lst->idx], pkt);
345
            if (ret < 0)
346
                break;
347
            lst->idx++;
348
        } else {
349
            /* The end of filter chain, break to return result */
350
            break;
351
        }
352
    }
353
354
    if (ret < 0)
355
        av_packet_unref(out);
356
357
    return ret;
358
}
359
360
static void bsf_list_flush(AVBSFContext *bsf)
361
{
362
    BSFListContext *lst = bsf->priv_data;
363
364
    for (int i = 0; i < lst->nb_bsfs; i++)
365
        av_bsf_flush(lst->bsfs[i]);
366
    lst->idx = lst->flushed_idx = 0;
367
}
368
369
static void bsf_list_close(AVBSFContext *bsf)
370
{
371
    BSFListContext *lst = bsf->priv_data;
372
    int i;
373
374
    for (i = 0; i < lst->nb_bsfs; ++i)
375
        av_bsf_free(&lst->bsfs[i]);
376
    av_freep(&lst->bsfs);
377
    av_freep(&lst->item_name);
378
}
379
380
static const char *bsf_list_item_name(void *ctx)
381
{
382
    static const char *null_filter_name = "null";
383
    AVBSFContext *bsf_ctx = ctx;
384
    BSFListContext *lst = bsf_ctx->priv_data;
385
386
    if (!lst->nb_bsfs)
387
        return null_filter_name;
388
389
    if (!lst->item_name) {
390
        int i;
391
        AVBPrint bp;
392
        av_bprint_init(&bp, 16, 128);
393
394
        av_bprintf(&bp, "bsf_list(");
395
        for (i = 0; i < lst->nb_bsfs; i++)
396
            av_bprintf(&bp, i ? ",%s" : "%s", lst->bsfs[i]->filter->name);
397
        av_bprintf(&bp, ")");
398
399
        av_bprint_finalize(&bp, &lst->item_name);
400
    }
401
402
    return lst->item_name;
403
}
404
405
static const AVClass bsf_list_class = {
406
        .class_name = "bsf_list",
407
        .item_name  = bsf_list_item_name,
408
        .version    = LIBAVUTIL_VERSION_INT,
409
};
410
411
const AVBitStreamFilter ff_list_bsf = {
412
        .name           = "bsf_list",
413
        .priv_data_size = sizeof(BSFListContext),
414
        .priv_class     = &bsf_list_class,
415
        .init           = bsf_list_init,
416
        .filter         = bsf_list_filter,
417
        .flush          = bsf_list_flush,
418
        .close          = bsf_list_close,
419
};
420
421
struct AVBSFList {
422
    AVBSFContext **bsfs;
423
    int nb_bsfs;
424
};
425
426
AVBSFList *av_bsf_list_alloc(void)
427
{
428
    return av_mallocz(sizeof(AVBSFList));
429
}
430
431
void av_bsf_list_free(AVBSFList **lst)
432
{
433
    int i;
434
435
    if (!*lst)
436
        return;
437
438
    for (i = 0; i < (*lst)->nb_bsfs; ++i)
439
        av_bsf_free(&(*lst)->bsfs[i]);
440
    av_free((*lst)->bsfs);
441
    av_freep(lst);
442
}
443
444
int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf)
445
{
446
    return av_dynarray_add_nofree(&lst->bsfs, &lst->nb_bsfs, bsf);
447
}
448
449
int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary ** options)
450
{
451
    int ret;
452
    const AVBitStreamFilter *filter;
453
    AVBSFContext *bsf;
454
455
    filter = av_bsf_get_by_name(bsf_name);
456
    if (!filter)
457
        return AVERROR_BSF_NOT_FOUND;
458
459
    ret = av_bsf_alloc(filter, &bsf);
460
    if (ret < 0)
461
        return ret;
462
463
    if (options) {
464
        ret = av_opt_set_dict2(bsf, options, AV_OPT_SEARCH_CHILDREN);
465
        if (ret < 0)
466
            goto end;
467
    }
468
469
    ret = av_bsf_list_append(lst, bsf);
470
471
end:
472
    if (ret < 0)
473
        av_bsf_free(&bsf);
474
475
    return ret;
476
}
477
478
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)
479
{
480
    int ret = 0;
481
    BSFListContext *ctx;
482
483
    if ((*lst)->nb_bsfs == 1) {
484
        *bsf = (*lst)->bsfs[0];
485
        av_freep(&(*lst)->bsfs);
486
        (*lst)->nb_bsfs = 0;
487
        goto end;
488
    }
489
490
    ret = av_bsf_alloc(&ff_list_bsf, bsf);
491
    if (ret < 0)
492
        return ret;
493
494
    ctx = (*bsf)->priv_data;
495
496
    ctx->bsfs = (*lst)->bsfs;
497
    ctx->nb_bsfs = (*lst)->nb_bsfs;
498
499
end:
500
    av_freep(lst);
501
    return ret;
502
}
503
504
static int bsf_parse_single(const char *str, AVBSFList *bsf_lst)
505
{
506
    char *bsf_name, *bsf_options_str, *buf;
507
    AVDictionary *bsf_options = NULL;
508
    int ret = 0;
509
510
    if (!(buf = av_strdup(str)))
511
        return AVERROR(ENOMEM);
512
513
    bsf_name = av_strtok(buf, "=", &bsf_options_str);
514
    if (!bsf_name) {
515
        ret = AVERROR(EINVAL);
516
        goto end;
517
    }
518
519
    if (bsf_options_str) {
520
        ret = av_dict_parse_string(&bsf_options, bsf_options_str, "=", ":", 0);
521
        if (ret < 0)
522
            goto end;
523
    }
524
525
    ret = av_bsf_list_append2(bsf_lst, bsf_name, &bsf_options);
526
527
end:
528
    av_dict_free(&bsf_options);
529
    av_free(buf);
530
    return ret;
531
}
532
533
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
534
{
535
    AVBSFList *lst;
536
    char *bsf_str, *buf, *dup, *saveptr;
537
    int ret;
538
539
    if (!str)
540
        return av_bsf_get_null_filter(bsf_lst);
541
542
    lst = av_bsf_list_alloc();
543
    if (!lst)
544
        return AVERROR(ENOMEM);
545
546
    if (!(dup = buf = av_strdup(str))) {
547
        ret = AVERROR(ENOMEM);
548
        goto end;
549
    }
550
551
    while (1) {
552
        bsf_str = av_strtok(buf, ",", &saveptr);
553
        if (!bsf_str)
554
            break;
555
556
        ret = bsf_parse_single(bsf_str, lst);
557
        if (ret < 0)
558
            goto end;
559
560
        buf = NULL;
561
    }
562
563
    ret = av_bsf_list_finalize(&lst, bsf_lst);
564
end:
565
    if (ret < 0)
566
        av_bsf_list_free(&lst);
567
    av_free(dup);
568
    return ret;
569
}
570
571
int av_bsf_get_null_filter(AVBSFContext **bsf)
572
{
573
    return av_bsf_alloc(&ff_list_bsf, bsf);
574
}