FFmpeg
h265_metadata_bsf.c
Go to the documentation of this file.
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 "bsf_internal.h"
24 #include "cbs.h"
25 #include "cbs_h265.h"
26 #include "hevc.h"
27 #include "h265_profile_level.h"
28 
29 enum {
33 };
34 
35 enum {
37  LEVEL_AUTO = -1,
38 };
39 
40 typedef struct H265MetadataContext {
41  const AVClass *class;
42 
46 
48 
49  int aud;
50 
52 
58 
60 
64 
65  int crop_left;
67  int crop_top;
69 
70  int level;
74 
75 
77  const CodedBitstreamFragment *au)
78 {
82  const H265RawHRDParameters *hrd = NULL;
83  int64_t bit_rate = 0;
84  int width = 0, height = 0;
85  int tile_cols = 0, tile_rows = 0;
86  int max_dec_pic_buffering = 0;
87  int i;
88 
89  for (i = 0; i < au->nb_units; i++) {
90  const CodedBitstreamUnit *unit = &au->units[i];
91 
92  if (unit->type == HEVC_NAL_VPS) {
93  const H265RawVPS *vps = unit->content;
94 
95  ptl = &vps->profile_tier_level;
96  max_dec_pic_buffering = vps->vps_max_dec_pic_buffering_minus1[0] + 1;
97 
98  if (vps->vps_num_hrd_parameters > 0)
99  hrd = &vps->hrd_parameters[0];
100 
101  } else if (unit->type == HEVC_NAL_SPS) {
102  const H265RawSPS *sps = unit->content;
103 
104  ptl = &sps->profile_tier_level;
105  max_dec_pic_buffering = sps->sps_max_dec_pic_buffering_minus1[0] + 1;
106 
107  width = sps->pic_width_in_luma_samples;
109 
111  hrd = &sps->vui.hrd_parameters;
112 
113  } else if (unit->type == HEVC_NAL_PPS) {
114  const H265RawPPS *pps = unit->content;
115 
116  if (pps->tiles_enabled_flag) {
117  tile_cols = pps->num_tile_columns_minus1 + 1;
118  tile_rows = pps->num_tile_rows_minus1 + 1;
119  }
120  }
121  }
122 
123  if (hrd) {
125  bit_rate = (hrd->nal_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *
126  (INT64_C(1) << hrd->bit_rate_scale + 6);
127  } else if (hrd->vcl_hrd_parameters_present_flag) {
128  bit_rate = (hrd->vcl_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *
129  (INT64_C(1) << hrd->bit_rate_scale + 6);
130  // Adjust for VCL vs. NAL limits.
131  bit_rate = bit_rate * 11 / 10;
132  }
133  }
134 
135  desc = ff_h265_guess_level(ptl, bit_rate, width, height,
136  0, tile_rows, tile_cols,
137  max_dec_pic_buffering);
138  if (desc) {
139  av_log(bsf, AV_LOG_DEBUG, "Stream appears to conform to "
140  "level %s.\n", desc->name);
141  ctx->level_guess = desc->level_idc;
142  }
143 }
144 
147 {
149 
150  if (ctx->level != LEVEL_UNSET) {
151  if (ctx->level == LEVEL_AUTO) {
152  if (ctx->level_guess) {
153  *level_idc = ctx->level_guess;
154  } else {
155  if (!ctx->level_warned) {
156  av_log(bsf, AV_LOG_WARNING, "Unable to determine level "
157  "of stream: using level 8.5.\n");
158  ctx->level_warned = 1;
159  }
160  *level_idc = 255;
161  }
162  } else {
163  *level_idc = ctx->level;
164  }
165  }
166 }
167 
169  H265RawVPS *vps)
170 {
172 
173  if (ctx->tick_rate.num && ctx->tick_rate.den) {
174  int num, den;
175 
176  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
177  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
178 
179  vps->vps_time_scale = num;
180  vps->vps_num_units_in_tick = den;
181 
183 
184  if (ctx->num_ticks_poc_diff_one > 0) {
186  ctx->num_ticks_poc_diff_one - 1;
188  } else if (ctx->num_ticks_poc_diff_one == 0) {
190  }
191  }
192 
194 
195  return 0;
196 }
197 
199  H265RawSPS *sps)
200 {
202  int need_vui = 0;
203  int crop_unit_x, crop_unit_y;
204 
205  if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
206  // Table E-1.
207  static const AVRational sar_idc[] = {
208  { 0, 0 }, // Unspecified (never written here).
209  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
210  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
211  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
212  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
213  };
214  int num, den, i;
215 
216  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
217  ctx->sample_aspect_ratio.den, 65535);
218 
219  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
220  if (num == sar_idc[i].num &&
221  den == sar_idc[i].den)
222  break;
223  }
224  if (i == FF_ARRAY_ELEMS(sar_idc)) {
225  sps->vui.aspect_ratio_idc = 255;
226  sps->vui.sar_width = num;
227  sps->vui.sar_height = den;
228  } else {
229  sps->vui.aspect_ratio_idc = i;
230  }
232  need_vui = 1;
233  }
234 
235 #define SET_OR_INFER(field, value, present_flag, infer) do { \
236  if (value >= 0) { \
237  field = value; \
238  need_vui = 1; \
239  } else if (!present_flag) \
240  field = infer; \
241  } while (0)
242 
243  if (ctx->video_format >= 0 ||
244  ctx->video_full_range_flag >= 0 ||
245  ctx->colour_primaries >= 0 ||
246  ctx->transfer_characteristics >= 0 ||
247  ctx->matrix_coefficients >= 0) {
248 
251 
255 
256  if (ctx->colour_primaries >= 0 ||
257  ctx->transfer_characteristics >= 0 ||
258  ctx->matrix_coefficients >= 0) {
259 
261  ctx->colour_primaries,
263 
267 
269  ctx->matrix_coefficients,
271 
273  }
275  need_vui = 1;
276  }
277 
278  if (ctx->chroma_sample_loc_type >= 0) {
284  need_vui = 1;
285  }
286 
287  if (ctx->tick_rate.num && ctx->tick_rate.den) {
288  int num, den;
289 
290  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
291  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
292 
293  sps->vui.vui_time_scale = num;
294  sps->vui.vui_num_units_in_tick = den;
295 
297  need_vui = 1;
298 
299  if (ctx->num_ticks_poc_diff_one > 0) {
301  ctx->num_ticks_poc_diff_one - 1;
303  } else if (ctx->num_ticks_poc_diff_one == 0) {
305  }
306  }
307 
308  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
309  crop_unit_x = 1;
310  crop_unit_y = 1;
311  } else {
312  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
313  crop_unit_y = 1 + (sps->chroma_format_idc < 2);
314  }
315 #define CROP(border, unit) do { \
316  if (ctx->crop_ ## border >= 0) { \
317  if (ctx->crop_ ## border % unit != 0) { \
318  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
319  "must be a multiple of %d.\n", #border, unit); \
320  return AVERROR(EINVAL); \
321  } \
322  sps->conf_win_ ## border ## _offset = \
323  ctx->crop_ ## border / unit; \
324  sps->conformance_window_flag = 1; \
325  } \
326  } while (0)
327  CROP(left, crop_unit_x);
328  CROP(right, crop_unit_x);
329  CROP(top, crop_unit_y);
330  CROP(bottom, crop_unit_y);
331 #undef CROP
332 
333  if (need_vui)
335 
337 
338  return 0;
339 }
340 
342 {
345  uint8_t *side_data;
346  int side_data_size;
347  int err, i;
348 
350  &side_data_size);
351  if (!side_data_size)
352  return 0;
353 
354  err = ff_cbs_read(ctx->input, au, side_data, side_data_size);
355  if (err < 0) {
356  av_log(bsf, AV_LOG_ERROR, "Failed to read extradata from packet side data.\n");
357  return err;
358  }
359 
360  if (ctx->level == LEVEL_AUTO && !ctx->level_guess)
361  h265_metadata_guess_level(bsf, au);
362 
363  for (i = 0; i < au->nb_units; i++) {
364  if (au->units[i].type == HEVC_NAL_VPS) {
365  err = h265_metadata_update_vps(bsf, au->units[i].content);
366  if (err < 0)
367  return err;
368  }
369  if (au->units[i].type == HEVC_NAL_SPS) {
370  err = h265_metadata_update_sps(bsf, au->units[i].content);
371  if (err < 0)
372  return err;
373  }
374  }
375 
376  err = ff_cbs_write_fragment_data(ctx->output, au);
377  if (err < 0) {
378  av_log(bsf, AV_LOG_ERROR, "Failed to write extradata into packet side data.\n");
379  return err;
380  }
381 
383  if (!side_data)
384  return AVERROR(ENOMEM);
385  memcpy(side_data, au->data, au->data_size);
386 
388 
389  return 0;
390 }
391 
393 {
396  int err, i;
397 
398  err = ff_bsf_get_packet_ref(bsf, pkt);
399  if (err < 0)
400  return err;
401 
402  err = h265_metadata_update_side_data(bsf, pkt);
403  if (err < 0)
404  goto fail;
405 
406  err = ff_cbs_read_packet(ctx->input, au, pkt);
407  if (err < 0) {
408  av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
409  goto fail;
410  }
411 
412  if (au->nb_units == 0) {
413  av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
414  err = AVERROR_INVALIDDATA;
415  goto fail;
416  }
417 
418  // If an AUD is present, it must be the first NAL unit.
419  if (au->units[0].type == HEVC_NAL_AUD) {
420  if (ctx->aud == REMOVE)
421  ff_cbs_delete_unit(au, 0);
422  } else {
423  if (ctx->aud == INSERT) {
424  H265RawAUD *aud = &ctx->aud_nal;
425  int pic_type = 0, temporal_id = 8, layer_id = 0;
426 
427  for (i = 0; i < au->nb_units; i++) {
428  const H265RawNALUnitHeader *nal = au->units[i].content;
429  if (!nal)
430  continue;
431  if (nal->nuh_temporal_id_plus1 < temporal_id + 1)
432  temporal_id = nal->nuh_temporal_id_plus1 - 1;
433 
434  if (au->units[i].type <= HEVC_NAL_RSV_VCL31) {
435  const H265RawSlice *slice = au->units[i].content;
436  layer_id = nal->nuh_layer_id;
437  if (slice->header.slice_type == HEVC_SLICE_B &&
438  pic_type < 2)
439  pic_type = 2;
440  if (slice->header.slice_type == HEVC_SLICE_P &&
441  pic_type < 1)
442  pic_type = 1;
443  }
444  }
445 
448  .nuh_layer_id = layer_id,
449  .nuh_temporal_id_plus1 = temporal_id + 1,
450  };
451  aud->pic_type = pic_type;
452 
453  err = ff_cbs_insert_unit_content(au, 0, HEVC_NAL_AUD, aud, NULL);
454  if (err < 0) {
455  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
456  goto fail;
457  }
458  }
459  }
460 
461  if (ctx->level == LEVEL_AUTO && !ctx->level_guess)
462  h265_metadata_guess_level(bsf, au);
463 
464  for (i = 0; i < au->nb_units; i++) {
465  if (au->units[i].type == HEVC_NAL_VPS) {
466  err = h265_metadata_update_vps(bsf, au->units[i].content);
467  if (err < 0)
468  goto fail;
469  }
470  if (au->units[i].type == HEVC_NAL_SPS) {
471  err = h265_metadata_update_sps(bsf, au->units[i].content);
472  if (err < 0)
473  goto fail;
474  }
475  }
476 
477  err = ff_cbs_write_packet(ctx->output, pkt, au);
478  if (err < 0) {
479  av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
480  goto fail;
481  }
482 
483  err = 0;
484 fail:
486 
487  if (err < 0)
488  av_packet_unref(pkt);
489 
490  return err;
491 }
492 
494 {
497  int err, i;
498 
499  err = ff_cbs_init(&ctx->input, AV_CODEC_ID_HEVC, bsf);
500  if (err < 0)
501  return err;
502  err = ff_cbs_init(&ctx->output, AV_CODEC_ID_HEVC, bsf);
503  if (err < 0)
504  return err;
505 
506  if (bsf->par_in->extradata) {
507  err = ff_cbs_read_extradata(ctx->input, au, bsf->par_in);
508  if (err < 0) {
509  av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
510  goto fail;
511  }
512 
513  if (ctx->level == LEVEL_AUTO)
514  h265_metadata_guess_level(bsf, au);
515 
516  for (i = 0; i < au->nb_units; i++) {
517  if (au->units[i].type == HEVC_NAL_VPS) {
518  err = h265_metadata_update_vps(bsf, au->units[i].content);
519  if (err < 0)
520  goto fail;
521  }
522  if (au->units[i].type == HEVC_NAL_SPS) {
523  err = h265_metadata_update_sps(bsf, au->units[i].content);
524  if (err < 0)
525  goto fail;
526  }
527  }
528 
529  err = ff_cbs_write_extradata(ctx->output, bsf->par_out, au);
530  if (err < 0) {
531  av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
532  goto fail;
533  }
534  }
535 
536  err = 0;
537 fail:
539  return err;
540 }
541 
543 {
545 
547  ff_cbs_close(&ctx->input);
548  ff_cbs_close(&ctx->output);
549 }
550 
551 #define OFFSET(x) offsetof(H265MetadataContext, x)
552 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
553 static const AVOption h265_metadata_options[] = {
554  { "aud", "Access Unit Delimiter NAL units",
556  { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
557  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
558  { .i64 = PASS }, .flags = FLAGS, .unit = "aud" },
559  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
560  { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
561  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
562  { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
563 
564  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
566  { .dbl = 0.0 }, 0, 65535, FLAGS },
567 
568  { "video_format", "Set video format (table E-2)",
570  { .i64 = -1 }, -1, 7, FLAGS },
571  { "video_full_range_flag", "Set video full range flag",
573  { .i64 = -1 }, -1, 1, FLAGS },
574  { "colour_primaries", "Set colour primaries (table E-3)",
576  { .i64 = -1 }, -1, 255, FLAGS },
577  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
579  { .i64 = -1 }, -1, 255, FLAGS },
580  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
582  { .i64 = -1 }, -1, 255, FLAGS },
583 
584  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
586  { .i64 = -1 }, -1, 6, FLAGS },
587 
588  { "tick_rate",
589  "Set VPS and VUI tick rate (num_units_in_tick / time_scale)",
591  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
592  { "num_ticks_poc_diff_one",
593  "Set VPS and VUI number of ticks per POC increment",
595  { .i64 = -1 }, -1, INT_MAX, FLAGS },
596 
597  { "crop_left", "Set left border crop offset",
599  { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
600  { "crop_right", "Set right border crop offset",
602  { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
603  { "crop_top", "Set top border crop offset",
605  { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
606  { "crop_bottom", "Set bottom border crop offset",
608  { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
609 
610  { "level", "Set level (tables A.6 and A.7)",
612  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
613  { "auto", "Attempt to guess level from stream properties",
615  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
616 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
617  { .i64 = value }, .flags = FLAGS, .unit = "level"
618  { LEVEL("1", 30) },
619  { LEVEL("2", 60) },
620  { LEVEL("2.1", 63) },
621  { LEVEL("3", 90) },
622  { LEVEL("3.1", 93) },
623  { LEVEL("4", 120) },
624  { LEVEL("4.1", 123) },
625  { LEVEL("5", 150) },
626  { LEVEL("5.1", 153) },
627  { LEVEL("5.2", 156) },
628  { LEVEL("6", 180) },
629  { LEVEL("6.1", 183) },
630  { LEVEL("6.2", 186) },
631  { LEVEL("8.5", 255) },
632 #undef LEVEL
633 
634  { NULL }
635 };
636 
637 static const AVClass h265_metadata_class = {
638  .class_name = "h265_metadata_bsf",
639  .item_name = av_default_item_name,
640  .option = h265_metadata_options,
641  .version = LIBAVUTIL_VERSION_INT,
642 };
643 
644 static const enum AVCodecID h265_metadata_codec_ids[] = {
646 };
647 
649  .name = "hevc_metadata",
650  .priv_data_size = sizeof(H265MetadataContext),
651  .priv_class = &h265_metadata_class,
653  .close = &h265_metadata_close,
656 };
uint32_t bit_rate_value_minus1[HEVC_MAX_CPB_CNT]
Definition: cbs_h265.h:101
#define NULL
Definition: coverity.c:32
static enum AVCodecID h265_metadata_codec_ids[]
int nb_units
Number of units in this fragment.
Definition: cbs.h:149
uint8_t transfer_characteristics
Definition: cbs_h265.h:149
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodecParameters * par_out
Parameters of the output stream.
Definition: bsf.h:83
uint8_t vps_poc_proportional_to_timing_flag
Definition: cbs_h265.h:216
AVOption.
Definition: opt.h:248
static void h265_metadata_update_level(AVBSFContext *bsf, uint8_t *level_idc)
H265RawHRDParameters hrd_parameters
Definition: cbs_h265.h:172
const char * desc
Definition: libsvtav1.c:79
uint8_t nal_hrd_parameters_present_flag
Definition: cbs_h265.h:109
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int ff_cbs_write_packet(CodedBitstreamContext *ctx, AVPacket *pkt, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to a packet.
Definition: cbs.c:397
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint8_t vui_timing_info_present_flag
Definition: cbs_h265.h:166
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:74
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:70
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: bsf.h:49
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
uint8_t tiles_enabled_flag
Definition: cbs_h265.h:384
uint8_t bit_rate_scale
Definition: cbs_h265.h:118
H265RawProfileTierLevel profile_tier_level
Definition: cbs_h265.h:260
static AVPacket pkt
uint8_t vui_parameters_present_flag
Definition: cbs_h265.h:318
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:70
uint32_t vps_num_units_in_tick
Definition: cbs_h265.h:214
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
static int h265_metadata_update_sps(AVBSFContext *bsf, H265RawSPS *sps)
int tile_cols
Definition: h265_levels.c:218
uint16_t pic_height_in_luma_samples
Definition: cbs_h265.h:268
#define OFFSET(x)
uint8_t
H265RawSubLayerHRDParameters nal_sub_layer_hrd_parameters[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:131
static const AVOption h265_metadata_options[]
AVOptions.
uint8_t colour_primaries
Definition: cbs_h265.h:148
uint8_t video_format
Definition: cbs_h265.h:145
uint8_t vps_timing_info_present_flag
Definition: cbs_h265.h:213
int level_idc
Definition: h264_levels.c:25
int ff_cbs_read_packet(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)
Read the data bitstream from a packet into a fragment, then split into units and decompose.
Definition: cbs.c:238
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
const char * name
Definition: bsf.h:99
#define height
uint8_t matrix_coefficients
Definition: cbs_h265.h:150
uint8_t aspect_ratio_info_present_flag
Definition: cbs_h265.h:136
uint8_t nuh_temporal_id_plus1
Definition: cbs_h265.h:40
static int h265_metadata_update_side_data(AVBSFContext *bsf, AVPacket *pkt)
Coded bitstream unit structure.
Definition: cbs.h:66
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:103
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:164
uint8_t video_full_range_flag
Definition: cbs_h265.h:146
#define av_log(a,...)
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment&#39;s own data buffer, but not the units a...
Definition: cbs.c:141
uint8_t chroma_sample_loc_type_bottom_field
Definition: cbs_h265.h:154
uint8_t video_signal_type_present_flag
Definition: cbs_h265.h:144
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:131
H265RawVUI vui
Definition: cbs_h265.h:319
uint32_t vui_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:170
uint8_t vps_max_dec_pic_buffering_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:205
static void h265_metadata_close(AVBSFContext *bsf)
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
uint8_t nuh_layer_id
Definition: cbs_h265.h:39
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
uint8_t chroma_loc_info_present_flag
Definition: cbs_h265.h:152
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
uint16_t sar_height
Definition: cbs_h265.h:139
#define fail()
Definition: checkasm.h:123
#define LEVEL(name, value)
uint8_t chroma_sample_loc_type_top_field
Definition: cbs_h265.h:153
uint32_t vui_time_scale
Definition: cbs_h265.h:168
H265RawHRDParameters hrd_parameters[HEVC_MAX_LAYER_SETS]
Definition: cbs_h265.h:221
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:446
uint8_t slice_type
Definition: cbs_h265.h:462
H265RawProfileTierLevel profile_tier_level
Definition: cbs_h265.h:202
int ff_cbs_write_extradata(CodedBitstreamContext *ctx, AVCodecParameters *par, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to the extradata in codec parameters.
Definition: cbs.c:372
uint8_t pic_type
Definition: cbs_h265.h:448
uint16_t sar_width
Definition: cbs_h265.h:138
#define width
uint8_t vui_hrd_parameters_present_flag
Definition: cbs_h265.h:171
AVFormatContext * ctx
Definition: movenc.c:48
uint16_t pic_width_in_luma_samples
Definition: cbs_h265.h:267
static int h265_metadata_init(AVBSFContext *bsf)
uint8_t vcl_hrd_parameters_present_flag
Definition: cbs_h265.h:110
H265RawSubLayerHRDParameters vcl_sub_layer_hrd_parameters[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:132
int tile_rows
Definition: h265_levels.c:217
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:124
#define FF_ARRAY_ELEMS(a)
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:336
uint16_t vps_num_hrd_parameters
Definition: cbs_h265.h:218
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
const H265LevelDescriptor * ff_h265_guess_level(const H265RawProfileTierLevel *ptl, int64_t bitrate, int width, int height, int slice_segments, int tile_rows, int tile_cols, int max_dec_pic_buffering)
Guess the level of a stream from some parameters.
CodedBitstreamContext * output
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:118
uint8_t general_level_idc
Definition: cbs_h265.h:68
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
uint32_t vui_num_units_in_tick
Definition: cbs_h265.h:167
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
CodedBitstreamFragment access_unit
Describe the class of an AVClass context structure.
Definition: log.h:67
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Context structure for coded bitstream operations.
Definition: cbs.h:170
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static void h265_metadata_guess_level(AVBSFContext *bsf, const CodedBitstreamFragment *au)
void ff_cbs_delete_unit(CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
Definition: cbs.c:790
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:715
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
uint8_t chroma_format_idc
Definition: cbs_h265.h:264
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:115
int ff_cbs_read_extradata(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecParameters *par)
Read the extradata bitstream found in codec parameters into a fragment, then split into units and dec...
Definition: cbs.c:220
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
#define CROP(border, unit)
uint8_t vui_poc_proportional_to_timing_flag
Definition: cbs_h265.h:169
const AVBitStreamFilter ff_hevc_metadata_bsf
static int h265_metadata_filter(AVBSFContext *bsf, AVPacket *pkt)
common internal and external API header
uint8_t num_tile_rows_minus1
Definition: cbs_h265.h:388
static enum AVCodecID codec_ids[]
uint8_t num_tile_columns_minus1
Definition: cbs_h265.h:387
static const AVClass h265_metadata_class
int den
Denominator.
Definition: rational.h:60
#define SET_OR_INFER(field, value, present_flag, infer)
static int h265_metadata_update_vps(AVBSFContext *bsf, H265RawVPS *vps)
H265RawSliceHeader header
Definition: cbs_h265.h:542
uint32_t vps_time_scale
Definition: cbs_h265.h:215
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:155
uint8_t aspect_ratio_idc
Definition: cbs_h265.h:137
uint8_t sps_max_dec_pic_buffering_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:282
AVRational sample_aspect_ratio
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
int ff_cbs_read(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const uint8_t *data, size_t size)
Read a bitstream from a memory region into a fragment, then split into units and decompose.
Definition: cbs.c:265
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint32_t vps_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:217
uint8_t separate_colour_plane_flag
Definition: cbs_h265.h:265
uint8_t colour_description_present_flag
Definition: cbs_h265.h:147
#define FLAGS
This structure stores compressed data.
Definition: packet.h:340
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:252
int i
Definition: input.c:407
uint8_t nal_unit_type
Definition: cbs_h265.h:38
CodedBitstreamContext * input