GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/h265_metadata_bsf.c Lines: 84 229 36.7 %
Date: 2019-11-20 04:07:19 Branches: 51 190 26.8 %

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_h265.h"
25
#include "hevc.h"
26
#include "h265_profile_level.h"
27
28
enum {
29
    PASS,
30
    INSERT,
31
    REMOVE,
32
};
33
34
enum {
35
    LEVEL_UNSET = -2,
36
    LEVEL_AUTO  = -1,
37
};
38
39
typedef struct H265MetadataContext {
40
    const AVClass *class;
41
42
    CodedBitstreamContext *cbc;
43
    CodedBitstreamFragment access_unit;
44
45
    H265RawAUD aud_nal;
46
47
    int aud;
48
49
    AVRational sample_aspect_ratio;
50
51
    int video_format;
52
    int video_full_range_flag;
53
    int colour_primaries;
54
    int transfer_characteristics;
55
    int matrix_coefficients;
56
57
    int chroma_sample_loc_type;
58
59
    AVRational tick_rate;
60
    int poc_proportional_to_timing_flag;
61
    int num_ticks_poc_diff_one;
62
63
    int crop_left;
64
    int crop_right;
65
    int crop_top;
66
    int crop_bottom;
67
68
    int level;
69
    int level_guess;
70
    int level_warned;
71
} H265MetadataContext;
72
73
74
static void h265_metadata_guess_level(AVBSFContext *bsf,
75
                                      const CodedBitstreamFragment *au)
76
{
77
    H265MetadataContext *ctx = bsf->priv_data;
78
    const H265LevelDescriptor *desc;
79
    const H265RawProfileTierLevel *ptl = NULL;
80
    const H265RawHRDParameters    *hrd = NULL;
81
    int64_t bit_rate = 0;
82
    int width = 0, height = 0;
83
    int tile_cols = 0, tile_rows = 0;
84
    int max_dec_pic_buffering = 0;
85
    int i;
86
87
    for (i = 0; i < au->nb_units; i++) {
88
        const CodedBitstreamUnit *unit = &au->units[i];
89
90
        if (unit->type == HEVC_NAL_VPS) {
91
            const H265RawVPS *vps = unit->content;
92
93
            ptl = &vps->profile_tier_level;
94
            max_dec_pic_buffering = vps->vps_max_dec_pic_buffering_minus1[0] + 1;
95
96
            if (vps->vps_num_hrd_parameters > 0)
97
                hrd = &vps->hrd_parameters[0];
98
99
        } else if (unit->type == HEVC_NAL_SPS) {
100
            const H265RawSPS *sps = unit->content;
101
102
            ptl = &sps->profile_tier_level;
103
            max_dec_pic_buffering = sps->sps_max_dec_pic_buffering_minus1[0] + 1;
104
105
            width  = sps->pic_width_in_luma_samples;
106
            height = sps->pic_height_in_luma_samples;
107
108
            if (sps->vui.vui_hrd_parameters_present_flag)
109
                hrd = &sps->vui.hrd_parameters;
110
111
        } else if (unit->type == HEVC_NAL_PPS) {
112
            const H265RawPPS *pps = unit->content;
113
114
            if (pps->tiles_enabled_flag) {
115
                tile_cols = pps->num_tile_columns_minus1 + 1;
116
                tile_rows = pps->num_tile_rows_minus1 + 1;
117
            }
118
        }
119
    }
120
121
    if (hrd) {
122
        if (hrd->nal_hrd_parameters_present_flag) {
123
            bit_rate = (hrd->nal_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *
124
                       (INT64_C(1) << hrd->bit_rate_scale + 6);
125
        } else if (hrd->vcl_hrd_parameters_present_flag) {
126
            bit_rate = (hrd->vcl_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *
127
                       (INT64_C(1) << hrd->bit_rate_scale + 6);
128
            // Adjust for VCL vs. NAL limits.
129
            bit_rate = bit_rate * 11 / 10;
130
        }
131
    }
132
133
    desc = ff_h265_guess_level(ptl, bit_rate, width, height,
134
                               0, tile_cols, tile_rows,
135
                               max_dec_pic_buffering);
136
    if (desc) {
137
        av_log(bsf, AV_LOG_DEBUG, "Stream appears to conform to "
138
               "level %s.\n", desc->name);
139
        ctx->level_guess = desc->level_idc;
140
    }
141
}
142
143
98
static void h265_metadata_update_level(AVBSFContext *bsf,
144
                                       uint8_t *level_idc)
145
{
146
98
    H265MetadataContext *ctx = bsf->priv_data;
147
148
98
    if (ctx->level != LEVEL_UNSET) {
149
        if (ctx->level == LEVEL_AUTO) {
150
            if (ctx->level_guess) {
151
                *level_idc = ctx->level_guess;
152
            } else {
153
                if (!ctx->level_warned) {
154
                    av_log(bsf, AV_LOG_WARNING, "Unable to determine level "
155
                           "of stream: using level 8.5.\n");
156
                    ctx->level_warned = 1;
157
                }
158
                *level_idc = 255;
159
            }
160
        } else {
161
            *level_idc = ctx->level;
162
        }
163
    }
164
98
}
165
166
48
static int h265_metadata_update_vps(AVBSFContext *bsf,
167
                                    H265RawVPS *vps)
168
{
169
48
    H265MetadataContext *ctx = bsf->priv_data;
170
171

48
    if (ctx->tick_rate.num && ctx->tick_rate.den) {
172
        int num, den;
173
174
        av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
175
                  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
176
177
        vps->vps_time_scale        = num;
178
        vps->vps_num_units_in_tick = den;
179
180
        vps->vps_timing_info_present_flag = 1;
181
182
        if (ctx->num_ticks_poc_diff_one > 0) {
183
            vps->vps_num_ticks_poc_diff_one_minus1 =
184
                ctx->num_ticks_poc_diff_one - 1;
185
            vps->vps_poc_proportional_to_timing_flag = 1;
186
        } else if (ctx->num_ticks_poc_diff_one == 0) {
187
            vps->vps_poc_proportional_to_timing_flag = 0;
188
        }
189
    }
190
191
48
    h265_metadata_update_level(bsf, &vps->profile_tier_level.general_level_idc);
192
193
48
    return 0;
194
}
195
196
50
static int h265_metadata_update_sps(AVBSFContext *bsf,
197
                                    H265RawSPS *sps)
198
{
199
50
    H265MetadataContext *ctx = bsf->priv_data;
200
50
    int need_vui = 0;
201
    int crop_unit_x, crop_unit_y;
202
203

50
    if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
204
        // Table E-1.
205
        static const AVRational sar_idc[] = {
206
            {   0,  0 }, // Unspecified (never written here).
207
            {   1,  1 }, {  12, 11 }, {  10, 11 }, {  16, 11 },
208
            {  40, 33 }, {  24, 11 }, {  20, 11 }, {  32, 11 },
209
            {  80, 33 }, {  18, 11 }, {  15, 11 }, {  64, 33 },
210
            { 160, 99 }, {   4,  3 }, {   3,  2 }, {   2,  1 },
211
        };
212
        int num, den, i;
213
214
        av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
215
                  ctx->sample_aspect_ratio.den, 65535);
216
217
        for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
218
            if (num == sar_idc[i].num &&
219
                den == sar_idc[i].den)
220
                break;
221
        }
222
        if (i == FF_ARRAY_ELEMS(sar_idc)) {
223
            sps->vui.aspect_ratio_idc = 255;
224
            sps->vui.sar_width  = num;
225
            sps->vui.sar_height = den;
226
        } else {
227
            sps->vui.aspect_ratio_idc = i;
228
        }
229
        sps->vui.aspect_ratio_info_present_flag = 1;
230
        need_vui = 1;
231
    }
232
233
#define SET_OR_INFER(field, value, present_flag, infer) do { \
234
        if (value >= 0) { \
235
            field = value; \
236
            need_vui = 1; \
237
        } else if (!present_flag) \
238
            field = infer; \
239
    } while (0)
240
241
50
    if (ctx->video_format             >= 0 ||
242
50
        ctx->video_full_range_flag    >= 0 ||
243
50
        ctx->colour_primaries         >= 0 ||
244
50
        ctx->transfer_characteristics >= 0 ||
245
50
        ctx->matrix_coefficients      >= 0) {
246
247
        SET_OR_INFER(sps->vui.video_format, ctx->video_format,
248
                     sps->vui.video_signal_type_present_flag, 5);
249
250
        SET_OR_INFER(sps->vui.video_full_range_flag,
251
                     ctx->video_full_range_flag,
252
                     sps->vui.video_signal_type_present_flag, 0);
253
254
        if (ctx->colour_primaries         >= 0 ||
255
            ctx->transfer_characteristics >= 0 ||
256
            ctx->matrix_coefficients      >= 0) {
257
258
            SET_OR_INFER(sps->vui.colour_primaries,
259
                         ctx->colour_primaries,
260
                         sps->vui.colour_description_present_flag, 2);
261
262
            SET_OR_INFER(sps->vui.transfer_characteristics,
263
                         ctx->transfer_characteristics,
264
                         sps->vui.colour_description_present_flag, 2);
265
266
            SET_OR_INFER(sps->vui.matrix_coefficients,
267
                         ctx->matrix_coefficients,
268
                         sps->vui.colour_description_present_flag, 2);
269
270
            sps->vui.colour_description_present_flag = 1;
271
        }
272
        sps->vui.video_signal_type_present_flag = 1;
273
        need_vui = 1;
274
    }
275
276
50
    if (ctx->chroma_sample_loc_type >= 0) {
277
        sps->vui.chroma_sample_loc_type_top_field =
278
            ctx->chroma_sample_loc_type;
279
        sps->vui.chroma_sample_loc_type_bottom_field =
280
            ctx->chroma_sample_loc_type;
281
        sps->vui.chroma_loc_info_present_flag = 1;
282
        need_vui = 1;
283
    }
284
285

50
    if (ctx->tick_rate.num && ctx->tick_rate.den) {
286
        int num, den;
287
288
        av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
289
                  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
290
291
        sps->vui.vui_time_scale        = num;
292
        sps->vui.vui_num_units_in_tick = den;
293
294
        sps->vui.vui_timing_info_present_flag = 1;
295
        need_vui = 1;
296
297
        if (ctx->num_ticks_poc_diff_one > 0) {
298
            sps->vui.vui_num_ticks_poc_diff_one_minus1 =
299
                ctx->num_ticks_poc_diff_one - 1;
300
            sps->vui.vui_poc_proportional_to_timing_flag = 1;
301
        } else if (ctx->num_ticks_poc_diff_one == 0) {
302
            sps->vui.vui_poc_proportional_to_timing_flag = 0;
303
        }
304
    }
305
306

50
    if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
307
        crop_unit_x = 1;
308
        crop_unit_y = 1;
309
    } else {
310
50
        crop_unit_x = 1 + (sps->chroma_format_idc < 3);
311
50
        crop_unit_y = 1 + (sps->chroma_format_idc < 2);
312
    }
313
#define CROP(border, unit) do { \
314
        if (ctx->crop_ ## border >= 0) { \
315
            if (ctx->crop_ ## border % unit != 0) { \
316
                av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
317
                       "must be a multiple of %d.\n", #border, unit); \
318
                return AVERROR(EINVAL); \
319
            } \
320
            sps->conf_win_ ## border ## _offset = \
321
                ctx->crop_ ## border / unit; \
322
            sps->conformance_window_flag = 1; \
323
        } \
324
    } while (0)
325

50
    CROP(left,   crop_unit_x);
326

50
    CROP(right,  crop_unit_x);
327

50
    CROP(top,    crop_unit_y);
328

50
    CROP(bottom, crop_unit_y);
329
#undef CROP
330
331
50
    if (need_vui)
332
        sps->vui_parameters_present_flag = 1;
333
334
50
    h265_metadata_update_level(bsf, &sps->profile_tier_level.general_level_idc);
335
336
50
    return 0;
337
}
338
339
4264
static int h265_metadata_filter(AVBSFContext *bsf, AVPacket *pkt)
340
{
341
4264
    H265MetadataContext *ctx = bsf->priv_data;
342
4264
    CodedBitstreamFragment *au = &ctx->access_unit;
343
    int err, i;
344
345
4264
    err = ff_bsf_get_packet_ref(bsf, pkt);
346
4264
    if (err < 0)
347
2132
        return err;
348
349
2132
    err = ff_cbs_read_packet(ctx->cbc, au, pkt);
350
2132
    if (err < 0) {
351
        av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
352
        goto fail;
353
    }
354
355
2132
    if (au->nb_units == 0) {
356
        av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
357
        err = AVERROR_INVALIDDATA;
358
        goto fail;
359
    }
360
361
    // If an AUD is present, it must be the first NAL unit.
362
2132
    if (au->units[0].type == HEVC_NAL_AUD) {
363
60
        if (ctx->aud == REMOVE)
364
            ff_cbs_delete_unit(ctx->cbc, au, 0);
365
    } else {
366
2072
        if (ctx->aud == INSERT) {
367
            H265RawAUD *aud = &ctx->aud_nal;
368
            int pic_type = 0, temporal_id = 8, layer_id = 0;
369
370
            for (i = 0; i < au->nb_units; i++) {
371
                const H265RawNALUnitHeader *nal = au->units[i].content;
372
                if (!nal)
373
                    continue;
374
                if (nal->nuh_temporal_id_plus1 < temporal_id + 1)
375
                    temporal_id = nal->nuh_temporal_id_plus1 - 1;
376
377
                if (au->units[i].type <= HEVC_NAL_RSV_VCL31) {
378
                    const H265RawSlice *slice = au->units[i].content;
379
                    layer_id = nal->nuh_layer_id;
380
                    if (slice->header.slice_type == HEVC_SLICE_B &&
381
                        pic_type < 2)
382
                        pic_type = 2;
383
                    if (slice->header.slice_type == HEVC_SLICE_P &&
384
                        pic_type < 1)
385
                        pic_type = 1;
386
                }
387
            }
388
389
            aud->nal_unit_header = (H265RawNALUnitHeader) {
390
                .nal_unit_type         = HEVC_NAL_AUD,
391
                .nuh_layer_id          = layer_id,
392
                .nuh_temporal_id_plus1 = temporal_id + 1,
393
            };
394
            aud->pic_type = pic_type;
395
396
            err = ff_cbs_insert_unit_content(ctx->cbc, au,
397
                                             0, HEVC_NAL_AUD, aud, NULL);
398
            if (err < 0) {
399
                av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
400
                goto fail;
401
            }
402
        }
403
    }
404
405

2132
    if (ctx->level == LEVEL_AUTO && !ctx->level_guess)
406
        h265_metadata_guess_level(bsf, au);
407
408
9900
    for (i = 0; i < au->nb_units; i++) {
409
7768
        if (au->units[i].type == HEVC_NAL_VPS) {
410
27
            err = h265_metadata_update_vps(bsf, au->units[i].content);
411
27
            if (err < 0)
412
                goto fail;
413
        }
414
7768
        if (au->units[i].type == HEVC_NAL_SPS) {
415
28
            err = h265_metadata_update_sps(bsf, au->units[i].content);
416
28
            if (err < 0)
417
                goto fail;
418
        }
419
    }
420
421
2132
    err = ff_cbs_write_packet(ctx->cbc, pkt, au);
422
2132
    if (err < 0) {
423
        av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
424
        goto fail;
425
    }
426
427
2132
    err = 0;
428
2132
fail:
429
2132
    ff_cbs_fragment_reset(ctx->cbc, au);
430
431
2132
    if (err < 0)
432
        av_packet_unref(pkt);
433
434
2132
    return err;
435
}
436
437
20
static int h265_metadata_init(AVBSFContext *bsf)
438
{
439
20
    H265MetadataContext *ctx = bsf->priv_data;
440
20
    CodedBitstreamFragment *au = &ctx->access_unit;
441
    int err, i;
442
443
20
    err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_HEVC, bsf);
444
20
    if (err < 0)
445
        return err;
446
447
20
    if (bsf->par_in->extradata) {
448
20
        err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
449
20
        if (err < 0) {
450
            av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
451
            goto fail;
452
        }
453
454
20
        if (ctx->level == LEVEL_AUTO)
455
            h265_metadata_guess_level(bsf, au);
456
457
84
        for (i = 0; i < au->nb_units; i++) {
458
64
            if (au->units[i].type == HEVC_NAL_VPS) {
459
21
                err = h265_metadata_update_vps(bsf, au->units[i].content);
460
21
                if (err < 0)
461
                    goto fail;
462
            }
463
64
            if (au->units[i].type == HEVC_NAL_SPS) {
464
22
                err = h265_metadata_update_sps(bsf, au->units[i].content);
465
22
                if (err < 0)
466
                    goto fail;
467
            }
468
        }
469
470
20
        err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
471
20
        if (err < 0) {
472
            av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
473
            goto fail;
474
        }
475
    }
476
477
20
    err = 0;
478
20
fail:
479
20
    ff_cbs_fragment_reset(ctx->cbc, au);
480
20
    return err;
481
}
482
483
20
static void h265_metadata_close(AVBSFContext *bsf)
484
{
485
20
    H265MetadataContext *ctx = bsf->priv_data;
486
487
20
    ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
488
20
    ff_cbs_close(&ctx->cbc);
489
20
}
490
491
#define OFFSET(x) offsetof(H265MetadataContext, x)
492
#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
493
static const AVOption h265_metadata_options[] = {
494
    { "aud", "Access Unit Delimiter NAL units",
495
        OFFSET(aud), AV_OPT_TYPE_INT,
496
        { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
497
    { "pass",   NULL, 0, AV_OPT_TYPE_CONST,
498
        { .i64 = PASS   }, .flags = FLAGS, .unit = "aud" },
499
    { "insert", NULL, 0, AV_OPT_TYPE_CONST,
500
        { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
501
    { "remove", NULL, 0, AV_OPT_TYPE_CONST,
502
        { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
503
504
    { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
505
        OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
506
        { .dbl = 0.0 }, 0, 65535, FLAGS },
507
508
    { "video_format", "Set video format (table E-2)",
509
        OFFSET(video_format), AV_OPT_TYPE_INT,
510
        { .i64 = -1 }, -1, 7, FLAGS },
511
    { "video_full_range_flag", "Set video full range flag",
512
        OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
513
        { .i64 = -1 }, -1, 1, FLAGS },
514
    { "colour_primaries", "Set colour primaries (table E-3)",
515
        OFFSET(colour_primaries), AV_OPT_TYPE_INT,
516
        { .i64 = -1 }, -1, 255, FLAGS },
517
    { "transfer_characteristics", "Set transfer characteristics (table E-4)",
518
        OFFSET(transfer_characteristics), AV_OPT_TYPE_INT,
519
        { .i64 = -1 }, -1, 255, FLAGS },
520
    { "matrix_coefficients", "Set matrix coefficients (table E-5)",
521
        OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
522
        { .i64 = -1 }, -1, 255, FLAGS },
523
524
    { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
525
        OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
526
        { .i64 = -1 }, -1, 6, FLAGS },
527
528
    { "tick_rate",
529
        "Set VPS and VUI tick rate (num_units_in_tick / time_scale)",
530
        OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
531
        { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
532
    { "num_ticks_poc_diff_one",
533
        "Set VPS and VUI number of ticks per POC increment",
534
        OFFSET(num_ticks_poc_diff_one), AV_OPT_TYPE_INT,
535
        { .i64 = -1 }, -1, INT_MAX, FLAGS },
536
537
    { "crop_left", "Set left border crop offset",
538
        OFFSET(crop_left), AV_OPT_TYPE_INT,
539
        { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
540
    { "crop_right", "Set right border crop offset",
541
        OFFSET(crop_right), AV_OPT_TYPE_INT,
542
        { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
543
    { "crop_top", "Set top border crop offset",
544
        OFFSET(crop_top), AV_OPT_TYPE_INT,
545
        { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
546
    { "crop_bottom", "Set bottom border crop offset",
547
        OFFSET(crop_bottom), AV_OPT_TYPE_INT,
548
        { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
549
550
    { "level", "Set level (tables A.6 and A.7)",
551
        OFFSET(level), AV_OPT_TYPE_INT,
552
        { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
553
    { "auto", "Attempt to guess level from stream properties",
554
        0, AV_OPT_TYPE_CONST,
555
        { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
556
#define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
557
        { .i64 = value },      .flags = FLAGS, .unit = "level"
558
    { LEVEL("1",    30) },
559
    { LEVEL("2",    60) },
560
    { LEVEL("2.1",  63) },
561
    { LEVEL("3",    90) },
562
    { LEVEL("3.1",  93) },
563
    { LEVEL("4",   120) },
564
    { LEVEL("4.1", 123) },
565
    { LEVEL("5",   150) },
566
    { LEVEL("5.1", 153) },
567
    { LEVEL("5.2", 156) },
568
    { LEVEL("6",   180) },
569
    { LEVEL("6.1", 183) },
570
    { LEVEL("6.2", 186) },
571
    { LEVEL("8.5", 255) },
572
#undef LEVEL
573
574
    { NULL }
575
};
576
577
static const AVClass h265_metadata_class = {
578
    .class_name = "h265_metadata_bsf",
579
    .item_name  = av_default_item_name,
580
    .option     = h265_metadata_options,
581
    .version    = LIBAVUTIL_VERSION_INT,
582
};
583
584
static const enum AVCodecID h265_metadata_codec_ids[] = {
585
    AV_CODEC_ID_HEVC, AV_CODEC_ID_NONE,
586
};
587
588
const AVBitStreamFilter ff_hevc_metadata_bsf = {
589
    .name           = "hevc_metadata",
590
    .priv_data_size = sizeof(H265MetadataContext),
591
    .priv_class     = &h265_metadata_class,
592
    .init           = &h265_metadata_init,
593
    .close          = &h265_metadata_close,
594
    .filter         = &h265_metadata_filter,
595
    .codec_ids      = h265_metadata_codec_ids,
596
};