GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/bsf.c Lines: 91 286 31.8 %
Date: 2020-01-29 01:05:39 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
31830
void av_bsf_free(AVBSFContext **pctx)
36
{
37
    AVBSFContext *ctx;
38
39

31830
    if (!pctx || !*pctx)
40
18666
        return;
41
13164
    ctx = *pctx;
42
43
13164
    if (ctx->filter->close)
44
1225
        ctx->filter->close(ctx);
45

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

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

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