GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/av1_metadata_bsf.c Lines: 59 107 55.1 %
Date: 2019-11-20 04:07:19 Branches: 29 78 37.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 "libavutil/common.h"
20
#include "libavutil/opt.h"
21
22
#include "bsf.h"
23
#include "cbs.h"
24
#include "cbs_av1.h"
25
26
enum {
27
    PASS,
28
    INSERT,
29
    REMOVE,
30
};
31
32
typedef struct AV1MetadataContext {
33
    const AVClass *class;
34
35
    CodedBitstreamContext *cbc;
36
    CodedBitstreamFragment access_unit;
37
38
    int td;
39
40
    int color_primaries;
41
    int transfer_characteristics;
42
    int matrix_coefficients;
43
44
    int color_range;
45
    int chroma_sample_position;
46
47
    AVRational tick_rate;
48
    int num_ticks_per_picture;
49
50
    int delete_padding;
51
} AV1MetadataContext;
52
53
54
264
static int av1_metadata_update_sequence_header(AVBSFContext *bsf,
55
                                               AV1RawSequenceHeader *seq)
56
{
57
264
    AV1MetadataContext *ctx = bsf->priv_data;
58
264
    AV1RawColorConfig  *clc = &seq->color_config;
59
264
    AV1RawTimingInfo   *tim = &seq->timing_info;
60
61
264
    if (ctx->color_primaries >= 0          ||
62
264
        ctx->transfer_characteristics >= 0 ||
63
264
        ctx->matrix_coefficients >= 0) {
64
        clc->color_description_present_flag = 1;
65
66
        if (ctx->color_primaries >= 0)
67
            clc->color_primaries = ctx->color_primaries;
68
        if (ctx->transfer_characteristics >= 0)
69
            clc->transfer_characteristics = ctx->transfer_characteristics;
70
        if (ctx->matrix_coefficients >= 0)
71
            clc->matrix_coefficients = ctx->matrix_coefficients;
72
    }
73
74
264
    if (ctx->color_range >= 0) {
75
        if (clc->color_primaries          == AVCOL_PRI_BT709        &&
76
            clc->transfer_characteristics == AVCOL_TRC_IEC61966_2_1 &&
77
            clc->matrix_coefficients      == AVCOL_SPC_RGB) {
78
            av_log(bsf, AV_LOG_WARNING, "Warning: color_range cannot be set "
79
                   "on RGB streams encoded in BT.709 sRGB.\n");
80
        } else {
81
            clc->color_range = ctx->color_range;
82
        }
83
    }
84
85
264
    if (ctx->chroma_sample_position >= 0) {
86
        if (clc->mono_chrome || !clc->subsampling_x || !clc->subsampling_y) {
87
            av_log(bsf, AV_LOG_WARNING, "Warning: chroma_sample_position "
88
                   "can only be set for 4:2:0 streams.\n");
89
        } else {
90
            clc->chroma_sample_position = ctx->chroma_sample_position;
91
        }
92
    }
93
94

264
    if (ctx->tick_rate.num && ctx->tick_rate.den) {
95
        int num, den;
96
97
        av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
98
                  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
99
100
        tim->time_scale                = num;
101
        tim->num_units_in_display_tick = den;
102
        seq->timing_info_present_flag  = 1;
103
104
        if (ctx->num_ticks_per_picture > 0) {
105
            tim->equal_picture_interval = 1;
106
            tim->num_ticks_per_picture_minus_1 =
107
                ctx->num_ticks_per_picture - 1;
108
        }
109
    }
110
111
264
    return 0;
112
}
113
114
741
static int av1_metadata_filter(AVBSFContext *bsf, AVPacket *pkt)
115
{
116
741
    AV1MetadataContext *ctx = bsf->priv_data;
117
741
    CodedBitstreamFragment *frag = &ctx->access_unit;
118
    AV1RawOBU td, *obu;
119
    int err, i;
120
121
741
    err = ff_bsf_get_packet_ref(bsf, pkt);
122
741
    if (err < 0)
123
247
        return err;
124
125
494
    err = ff_cbs_read_packet(ctx->cbc, frag, pkt);
126
494
    if (err < 0) {
127
        av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
128
        goto fail;
129
    }
130
131
494
    if (frag->nb_units == 0) {
132
        av_log(bsf, AV_LOG_ERROR, "No OBU in packet.\n");
133
        err = AVERROR_INVALIDDATA;
134
        goto fail;
135
    }
136
137
1856
    for (i = 0; i < frag->nb_units; i++) {
138
1362
        if (frag->units[i].type == AV1_OBU_SEQUENCE_HEADER) {
139
242
            obu = frag->units[i].content;
140
242
            err = av1_metadata_update_sequence_header(bsf, &obu->obu.sequence_header);
141
242
            if (err < 0)
142
                goto fail;
143
        }
144
    }
145
146
    // If a Temporal Delimiter is present, it must be the first OBU.
147
494
    if (frag->units[0].type == AV1_OBU_TEMPORAL_DELIMITER) {
148
494
        if (ctx->td == REMOVE)
149
            ff_cbs_delete_unit(ctx->cbc, frag, 0);
150
    } else if (ctx->td == INSERT) {
151
        td = (AV1RawOBU) {
152
            .header.obu_type = AV1_OBU_TEMPORAL_DELIMITER,
153
        };
154
155
        err = ff_cbs_insert_unit_content(ctx->cbc, frag, 0, AV1_OBU_TEMPORAL_DELIMITER,
156
                                         &td, NULL);
157
        if (err < 0) {
158
            av_log(bsf, AV_LOG_ERROR, "Failed to insert Temporal Delimiter.\n");
159
            goto fail;
160
        }
161
    }
162
163
494
    if (ctx->delete_padding) {
164
        for (i = frag->nb_units - 1; i >= 0; i--) {
165
            if (frag->units[i].type == AV1_OBU_PADDING)
166
                ff_cbs_delete_unit(ctx->cbc, frag, i);
167
        }
168
    }
169
170
494
    err = ff_cbs_write_packet(ctx->cbc, pkt, frag);
171
494
    if (err < 0) {
172
        av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
173
        goto fail;
174
    }
175
176
494
    err = 0;
177
494
fail:
178
494
    ff_cbs_fragment_reset(ctx->cbc, frag);
179
180
494
    if (err < 0)
181
        av_packet_unref(pkt);
182
183
494
    return err;
184
}
185
186
22
static int av1_metadata_init(AVBSFContext *bsf)
187
{
188
22
    AV1MetadataContext *ctx = bsf->priv_data;
189
22
    CodedBitstreamFragment *frag = &ctx->access_unit;
190
    AV1RawOBU *obu;
191
    int err, i;
192
193
22
    err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_AV1, bsf);
194
22
    if (err < 0)
195
        return err;
196
197
22
    if (bsf->par_in->extradata) {
198
22
        err = ff_cbs_read_extradata(ctx->cbc, frag, bsf->par_in);
199
22
        if (err < 0) {
200
            av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
201
            goto fail;
202
        }
203
204
52
        for (i = 0; i < frag->nb_units; i++) {
205
30
            if (frag->units[i].type == AV1_OBU_SEQUENCE_HEADER) {
206
22
                obu = frag->units[i].content;
207
22
                err = av1_metadata_update_sequence_header(bsf, &obu->obu.sequence_header);
208
22
                if (err < 0)
209
                    goto fail;
210
            }
211
        }
212
213
22
        err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, frag);
214
22
        if (err < 0) {
215
            av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
216
            goto fail;
217
        }
218
    }
219
220
22
    err = 0;
221
22
fail:
222
22
    ff_cbs_fragment_reset(ctx->cbc, frag);
223
22
    return err;
224
}
225
226
22
static void av1_metadata_close(AVBSFContext *bsf)
227
{
228
22
    AV1MetadataContext *ctx = bsf->priv_data;
229
230
22
    ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
231
22
    ff_cbs_close(&ctx->cbc);
232
22
}
233
234
#define OFFSET(x) offsetof(AV1MetadataContext, x)
235
#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
236
static const AVOption av1_metadata_options[] = {
237
    { "td", "Temporal Delimiter OBU",
238
        OFFSET(td), AV_OPT_TYPE_INT,
239
        { .i64 = PASS }, PASS, REMOVE, FLAGS, "td" },
240
    { "pass",   NULL, 0, AV_OPT_TYPE_CONST,
241
        { .i64 = PASS   }, .flags = FLAGS, .unit = "td" },
242
    { "insert", NULL, 0, AV_OPT_TYPE_CONST,
243
        { .i64 = INSERT }, .flags = FLAGS, .unit = "td" },
244
    { "remove", NULL, 0, AV_OPT_TYPE_CONST,
245
        { .i64 = REMOVE }, .flags = FLAGS, .unit = "td" },
246
247
    { "color_primaries", "Set color primaries (section 6.4.2)",
248
        OFFSET(color_primaries), AV_OPT_TYPE_INT,
249
        { .i64 = -1 }, -1, 255, FLAGS },
250
    { "transfer_characteristics", "Set transfer characteristics (section 6.4.2)",
251
        OFFSET(transfer_characteristics), AV_OPT_TYPE_INT,
252
        { .i64 = -1 }, -1, 255, FLAGS },
253
    { "matrix_coefficients", "Set matrix coefficients (section 6.4.2)",
254
        OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
255
        { .i64 = -1 }, -1, 255, FLAGS },
256
257
    { "color_range", "Set color range flag (section 6.4.2)",
258
        OFFSET(color_range), AV_OPT_TYPE_INT,
259
        { .i64 = -1 }, -1, 1, FLAGS, "cr" },
260
    { "tv", "TV (limited) range", 0, AV_OPT_TYPE_CONST,
261
        { .i64 = 0 }, .flags = FLAGS, .unit = "cr" },
262
    { "pc", "PC (full) range",    0, AV_OPT_TYPE_CONST,
263
        { .i64 = 1 }, .flags = FLAGS, .unit = "cr" },
264
265
    { "chroma_sample_position", "Set chroma sample position (section 6.4.2)",
266
        OFFSET(chroma_sample_position), AV_OPT_TYPE_INT,
267
        { .i64 = -1 }, -1, 3, FLAGS, "csp" },
268
    { "unknown",   "Unknown chroma sample position",  0, AV_OPT_TYPE_CONST,
269
        { .i64 = AV1_CSP_UNKNOWN },   .flags = FLAGS, .unit = "csp" },
270
    { "vertical",  "Left chroma sample position",     0, AV_OPT_TYPE_CONST,
271
        { .i64 = AV1_CSP_VERTICAL },  .flags = FLAGS, .unit = "csp" },
272
    { "colocated", "Top-left chroma sample position", 0, AV_OPT_TYPE_CONST,
273
        { .i64 = AV1_CSP_COLOCATED }, .flags = FLAGS, .unit = "csp" },
274
275
    { "tick_rate", "Set display tick rate (num_units_in_display_tick / time_scale)",
276
        OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
277
        { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
278
    { "num_ticks_per_picture", "Set display ticks per picture for CFR streams",
279
        OFFSET(num_ticks_per_picture), AV_OPT_TYPE_INT,
280
        { .i64 = -1 }, -1, INT_MAX, FLAGS },
281
282
    { "delete_padding", "Delete all Padding OBUs",
283
        OFFSET(delete_padding), AV_OPT_TYPE_BOOL,
284
        { .i64 = 0 }, 0, 1, FLAGS},
285
286
    { NULL }
287
};
288
289
static const AVClass av1_metadata_class = {
290
    .class_name = "av1_metadata_bsf",
291
    .item_name  = av_default_item_name,
292
    .option     = av1_metadata_options,
293
    .version    = LIBAVUTIL_VERSION_INT,
294
};
295
296
static const enum AVCodecID av1_metadata_codec_ids[] = {
297
    AV_CODEC_ID_AV1, AV_CODEC_ID_NONE,
298
};
299
300
const AVBitStreamFilter ff_av1_metadata_bsf = {
301
    .name           = "av1_metadata",
302
    .priv_data_size = sizeof(AV1MetadataContext),
303
    .priv_class     = &av1_metadata_class,
304
    .init           = &av1_metadata_init,
305
    .close          = &av1_metadata_close,
306
    .filter         = &av1_metadata_filter,
307
    .codec_ids      = av1_metadata_codec_ids,
308
};