GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/filter_units_bsf.c Lines: 0 103 0.0 %
Date: 2019-11-18 18:00:01 Branches: 0 64 0.0 %

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 <stdlib.h>
20
21
#include "libavutil/common.h"
22
#include "libavutil/opt.h"
23
24
#include "bsf.h"
25
#include "cbs.h"
26
27
28
typedef struct FilterUnitsContext {
29
    const AVClass *class;
30
31
    CodedBitstreamContext *cbc;
32
    CodedBitstreamFragment fragment;
33
34
    const char *pass_types;
35
    const char *remove_types;
36
37
    enum {
38
        NOOP,
39
        PASS,
40
        REMOVE,
41
    } mode;
42
    CodedBitstreamUnitType *type_list;
43
    int nb_types;
44
} FilterUnitsContext;
45
46
47
static int filter_units_make_type_list(const char *list_string,
48
                                       CodedBitstreamUnitType **type_list,
49
                                       int *nb_types)
50
{
51
    CodedBitstreamUnitType *list = NULL;
52
    int pass, count;
53
54
    for (pass = 1; pass <= 2; pass++) {
55
        long value, range_start, range_end;
56
        const char *str;
57
        char *value_end;
58
59
        count = 0;
60
        for (str = list_string; *str;) {
61
            value = strtol(str, &value_end, 0);
62
            if (str == value_end)
63
                goto invalid;
64
            str = (const char *)value_end;
65
            if (*str == '-') {
66
                ++str;
67
                range_start = value;
68
                range_end   = strtol(str, &value_end, 0);
69
                if (str == value_end)
70
                    goto invalid;
71
72
                for (value = range_start; value < range_end; value++) {
73
                    if (pass == 2)
74
                        list[count] = value;
75
                    ++count;
76
                }
77
            } else {
78
                if (pass == 2)
79
                    list[count] = value;
80
                ++count;
81
            }
82
            if (*str == '|')
83
                ++str;
84
        }
85
        if (pass == 1) {
86
            list = av_malloc_array(count, sizeof(*list));
87
            if (!list)
88
                return AVERROR(ENOMEM);
89
        }
90
    }
91
92
    *type_list = list;
93
    *nb_types  = count;
94
    return 0;
95
96
invalid:
97
    av_freep(&list);
98
    return AVERROR(EINVAL);
99
}
100
101
static int filter_units_filter(AVBSFContext *bsf, AVPacket *pkt)
102
{
103
    FilterUnitsContext      *ctx = bsf->priv_data;
104
    CodedBitstreamFragment *frag = &ctx->fragment;
105
    int err, i, j;
106
107
    err = ff_bsf_get_packet_ref(bsf, pkt);
108
    if (err < 0)
109
        return err;
110
111
    if (ctx->mode == NOOP)
112
        return 0;
113
114
    err = ff_cbs_read_packet(ctx->cbc, frag, pkt);
115
    if (err < 0) {
116
        av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
117
        goto fail;
118
    }
119
120
    for (i = frag->nb_units - 1; i >= 0; i--) {
121
        for (j = 0; j < ctx->nb_types; j++) {
122
            if (frag->units[i].type == ctx->type_list[j])
123
                break;
124
        }
125
        if (ctx->mode == REMOVE ? j <  ctx->nb_types
126
                                : j >= ctx->nb_types)
127
            ff_cbs_delete_unit(ctx->cbc, frag, i);
128
    }
129
130
    if (frag->nb_units == 0) {
131
        // Don't return packets with nothing in them.
132
        err = AVERROR(EAGAIN);
133
        goto fail;
134
    }
135
136
    err = ff_cbs_write_packet(ctx->cbc, pkt, frag);
137
    if (err < 0) {
138
        av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
139
        goto fail;
140
    }
141
142
fail:
143
    if (err < 0)
144
        av_packet_unref(pkt);
145
    ff_cbs_fragment_reset(ctx->cbc, frag);
146
147
    return err;
148
}
149
150
static int filter_units_init(AVBSFContext *bsf)
151
{
152
    FilterUnitsContext *ctx = bsf->priv_data;
153
    int err;
154
155
    if (ctx->pass_types && ctx->remove_types) {
156
        av_log(bsf, AV_LOG_ERROR, "Exactly one of pass_types or "
157
               "remove_types is required.\n");
158
        return AVERROR(EINVAL);
159
    }
160
161
    if (ctx->pass_types) {
162
        ctx->mode = PASS;
163
        err = filter_units_make_type_list(ctx->pass_types,
164
                                          &ctx->type_list, &ctx->nb_types);
165
        if (err < 0) {
166
            av_log(bsf, AV_LOG_ERROR, "Failed to parse pass_types.\n");
167
            return err;
168
        }
169
    } else if (ctx->remove_types) {
170
        ctx->mode = REMOVE;
171
        err = filter_units_make_type_list(ctx->remove_types,
172
                                          &ctx->type_list, &ctx->nb_types);
173
        if (err < 0) {
174
            av_log(bsf, AV_LOG_ERROR, "Failed to parse remove_types.\n");
175
            return err;
176
        }
177
    } else {
178
        return 0;
179
    }
180
181
    err = ff_cbs_init(&ctx->cbc, bsf->par_in->codec_id, bsf);
182
    if (err < 0)
183
        return err;
184
185
    // Don't actually decompose anything, we only want the unit data.
186
    ctx->cbc->decompose_unit_types    = ctx->type_list;
187
    ctx->cbc->nb_decompose_unit_types = 0;
188
189
    if (bsf->par_in->extradata) {
190
        CodedBitstreamFragment *frag = &ctx->fragment;
191
192
        err = ff_cbs_read_extradata(ctx->cbc, frag, bsf->par_in);
193
        if (err < 0) {
194
            av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
195
        } else {
196
            err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, frag);
197
            if (err < 0)
198
                av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
199
        }
200
201
        ff_cbs_fragment_reset(ctx->cbc, frag);
202
    }
203
204
    return err;
205
}
206
207
static void filter_units_close(AVBSFContext *bsf)
208
{
209
    FilterUnitsContext *ctx = bsf->priv_data;
210
211
    av_freep(&ctx->type_list);
212
213
    ff_cbs_fragment_free(ctx->cbc, &ctx->fragment);
214
    ff_cbs_close(&ctx->cbc);
215
}
216
217
#define OFFSET(x) offsetof(FilterUnitsContext, x)
218
#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
219
static const AVOption filter_units_options[] = {
220
    { "pass_types",   "List of unit types to pass through the filter.",
221
        OFFSET(pass_types),   AV_OPT_TYPE_STRING,
222
        { .str = NULL }, .flags = FLAGS },
223
    { "remove_types", "List of unit types to remove in the filter.",
224
        OFFSET(remove_types), AV_OPT_TYPE_STRING,
225
        { .str = NULL }, .flags = FLAGS },
226
227
    { NULL }
228
};
229
230
static const AVClass filter_units_class = {
231
    .class_name = "filter_units",
232
    .item_name  = av_default_item_name,
233
    .option     = filter_units_options,
234
    .version    = LIBAVUTIL_VERSION_INT,
235
};
236
237
const AVBitStreamFilter ff_filter_units_bsf = {
238
    .name           = "filter_units",
239
    .priv_data_size = sizeof(FilterUnitsContext),
240
    .priv_class     = &filter_units_class,
241
    .init           = &filter_units_init,
242
    .close          = &filter_units_close,
243
    .filter         = &filter_units_filter,
244
    .codec_ids      = ff_cbs_all_codec_ids,
245
};