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 "cbs.h"
24 #include "cbs_bsf.h"
25 #include "cbs_h265.h"
26 #include "hevc.h"
27 #include "h265_profile_level.h"
28 
29 enum {
31  LEVEL_AUTO = -1,
32 };
33 
34 typedef struct H265MetadataContext {
36 
38 
39  int aud;
40 
42 
48 
50 
54 
55  int crop_left;
57  int crop_top;
59 
60  int level;
64 
65 
67  const CodedBitstreamFragment *au)
68 {
72  const H265RawHRDParameters *hrd = NULL;
73  int64_t bit_rate = 0;
74  int width = 0, height = 0;
75  int tile_cols = 0, tile_rows = 0;
76  int max_dec_pic_buffering = 0;
77  int i;
78 
79  for (i = 0; i < au->nb_units; i++) {
80  const CodedBitstreamUnit *unit = &au->units[i];
81 
82  if (unit->type == HEVC_NAL_VPS) {
83  const H265RawVPS *vps = unit->content;
84 
85  ptl = &vps->profile_tier_level;
86  max_dec_pic_buffering = vps->vps_max_dec_pic_buffering_minus1[0] + 1;
87 
88  if (vps->vps_num_hrd_parameters > 0)
89  hrd = &vps->hrd_parameters[0];
90 
91  } else if (unit->type == HEVC_NAL_SPS) {
92  const H265RawSPS *sps = unit->content;
93 
94  ptl = &sps->profile_tier_level;
95  max_dec_pic_buffering = sps->sps_max_dec_pic_buffering_minus1[0] + 1;
96 
97  width = sps->pic_width_in_luma_samples;
99 
101  hrd = &sps->vui.hrd_parameters;
102 
103  } else if (unit->type == HEVC_NAL_PPS) {
104  const H265RawPPS *pps = unit->content;
105 
106  if (pps->tiles_enabled_flag) {
107  tile_cols = pps->num_tile_columns_minus1 + 1;
108  tile_rows = pps->num_tile_rows_minus1 + 1;
109  }
110  }
111  }
112 
113  if (hrd) {
115  bit_rate = (hrd->nal_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *
116  (INT64_C(1) << hrd->bit_rate_scale + 6);
117  } else if (hrd->vcl_hrd_parameters_present_flag) {
118  bit_rate = (hrd->vcl_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *
119  (INT64_C(1) << hrd->bit_rate_scale + 6);
120  // Adjust for VCL vs. NAL limits.
121  bit_rate = bit_rate * 11 / 10;
122  }
123  }
124 
125  desc = ff_h265_guess_level(ptl, bit_rate, width, height,
126  0, tile_rows, tile_cols,
127  max_dec_pic_buffering);
128  if (desc) {
129  av_log(bsf, AV_LOG_DEBUG, "Stream appears to conform to "
130  "level %s.\n", desc->name);
131  ctx->level_guess = desc->level_idc;
132  }
133 }
134 
137 {
139 
140  if (ctx->level != LEVEL_UNSET) {
141  if (ctx->level == LEVEL_AUTO) {
142  if (ctx->level_guess) {
143  *level_idc = ctx->level_guess;
144  } else {
145  if (!ctx->level_warned) {
146  av_log(bsf, AV_LOG_WARNING, "Unable to determine level "
147  "of stream: using level 8.5.\n");
148  ctx->level_warned = 1;
149  }
150  *level_idc = 255;
151  }
152  } else {
153  *level_idc = ctx->level;
154  }
155  }
156 }
157 
159  H265RawVPS *vps)
160 {
162 
163  if (ctx->tick_rate.num && ctx->tick_rate.den) {
164  int num, den;
165 
166  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
167  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
168 
169  vps->vps_time_scale = num;
170  vps->vps_num_units_in_tick = den;
171 
173 
174  if (ctx->num_ticks_poc_diff_one > 0) {
176  ctx->num_ticks_poc_diff_one - 1;
178  } else if (ctx->num_ticks_poc_diff_one == 0) {
180  }
181  }
182 
184 
185  return 0;
186 }
187 
189  H265RawSPS *sps)
190 {
192  int need_vui = 0;
193  int crop_unit_x, crop_unit_y;
194 
195  if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
196  // Table E-1.
197  static const AVRational sar_idc[] = {
198  { 0, 0 }, // Unspecified (never written here).
199  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
200  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
201  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
202  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
203  };
204  int num, den, i;
205 
206  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
207  ctx->sample_aspect_ratio.den, 65535);
208 
209  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
210  if (num == sar_idc[i].num &&
211  den == sar_idc[i].den)
212  break;
213  }
214  if (i == FF_ARRAY_ELEMS(sar_idc)) {
215  sps->vui.aspect_ratio_idc = 255;
216  sps->vui.sar_width = num;
217  sps->vui.sar_height = den;
218  } else {
219  sps->vui.aspect_ratio_idc = i;
220  }
222  need_vui = 1;
223  }
224 
225 #define SET_OR_INFER(field, value, present_flag, infer) do { \
226  if (value >= 0) { \
227  field = value; \
228  need_vui = 1; \
229  } else if (!present_flag) \
230  field = infer; \
231  } while (0)
232 
233  if (ctx->video_format >= 0 ||
234  ctx->video_full_range_flag >= 0 ||
235  ctx->colour_primaries >= 0 ||
236  ctx->transfer_characteristics >= 0 ||
237  ctx->matrix_coefficients >= 0) {
238 
241 
245 
246  if (ctx->colour_primaries >= 0 ||
247  ctx->transfer_characteristics >= 0 ||
248  ctx->matrix_coefficients >= 0) {
249 
251  ctx->colour_primaries,
253 
257 
259  ctx->matrix_coefficients,
261 
263  }
265  need_vui = 1;
266  }
267 
268  if (ctx->chroma_sample_loc_type >= 0) {
274  need_vui = 1;
275  }
276 
277  if (ctx->tick_rate.num && ctx->tick_rate.den) {
278  int num, den;
279 
280  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
281  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
282 
283  sps->vui.vui_time_scale = num;
284  sps->vui.vui_num_units_in_tick = den;
285 
287  need_vui = 1;
288 
289  if (ctx->num_ticks_poc_diff_one > 0) {
291  ctx->num_ticks_poc_diff_one - 1;
293  } else if (ctx->num_ticks_poc_diff_one == 0) {
295  }
296  }
297 
298  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
299  crop_unit_x = 1;
300  crop_unit_y = 1;
301  } else {
302  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
303  crop_unit_y = 1 + (sps->chroma_format_idc < 2);
304  }
305 #define CROP(border, unit) do { \
306  if (ctx->crop_ ## border >= 0) { \
307  if (ctx->crop_ ## border % unit != 0) { \
308  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
309  "must be a multiple of %d.\n", #border, unit); \
310  return AVERROR(EINVAL); \
311  } \
312  sps->conf_win_ ## border ## _offset = \
313  ctx->crop_ ## border / unit; \
314  sps->conformance_window_flag = 1; \
315  } \
316  } while (0)
317  CROP(left, crop_unit_x);
318  CROP(right, crop_unit_x);
319  CROP(top, crop_unit_y);
320  CROP(bottom, crop_unit_y);
321 #undef CROP
322 
323  if (need_vui)
325 
327 
328  return 0;
329 }
330 
333 {
335  int err, i;
336 
337  // If an AUD is present, it must be the first NAL unit.
338  if (au->units[0].type == HEVC_NAL_AUD) {
339  if (ctx->aud == BSF_ELEMENT_REMOVE)
340  ff_cbs_delete_unit(au, 0);
341  } else {
342  if (pkt && ctx->aud == BSF_ELEMENT_INSERT) {
343  H265RawAUD *aud = &ctx->aud_nal;
344  int pic_type = 0, temporal_id = 8, layer_id = 0;
345 
346  for (i = 0; i < au->nb_units; i++) {
347  const H265RawNALUnitHeader *nal = au->units[i].content;
348  if (!nal)
349  continue;
350  if (nal->nuh_temporal_id_plus1 < temporal_id + 1)
351  temporal_id = nal->nuh_temporal_id_plus1 - 1;
352 
353  if (au->units[i].type <= HEVC_NAL_RSV_VCL31) {
354  const H265RawSlice *slice = au->units[i].content;
355  layer_id = nal->nuh_layer_id;
356  if (slice->header.slice_type == HEVC_SLICE_B &&
357  pic_type < 2)
358  pic_type = 2;
359  if (slice->header.slice_type == HEVC_SLICE_P &&
360  pic_type < 1)
361  pic_type = 1;
362  }
363  }
364 
367  .nuh_layer_id = layer_id,
368  .nuh_temporal_id_plus1 = temporal_id + 1,
369  };
370  aud->pic_type = pic_type;
371 
372  err = ff_cbs_insert_unit_content(au, 0, HEVC_NAL_AUD, aud, NULL);
373  if (err < 0) {
374  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
375  return err;
376  }
377  }
378  }
379 
380  if (ctx->level == LEVEL_AUTO && !ctx->level_guess)
381  h265_metadata_guess_level(bsf, au);
382 
383  for (i = 0; i < au->nb_units; i++) {
384  if (au->units[i].type == HEVC_NAL_VPS) {
385  err = h265_metadata_update_vps(bsf, au->units[i].content);
386  if (err < 0)
387  return err;
388  }
389  if (au->units[i].type == HEVC_NAL_SPS) {
390  err = h265_metadata_update_sps(bsf, au->units[i].content);
391  if (err < 0)
392  return err;
393  }
394  }
395 
396  return 0;
397 }
398 
401  .fragment_name = "access unit",
402  .unit_name = "NAL unit",
403  .update_fragment = &h265_metadata_update_fragment,
404 };
405 
407 {
408  return ff_cbs_bsf_generic_init(bsf, &h265_metadata_type);
409 }
410 
411 #define OFFSET(x) offsetof(H265MetadataContext, x)
412 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
413 static const AVOption h265_metadata_options[] = {
414  BSF_ELEMENT_OPTIONS_PIR("aud", "Access Unit Delimiter NAL units",
415  aud, FLAGS),
416 
417  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
419  { .dbl = 0.0 }, 0, 65535, FLAGS },
420 
421  { "video_format", "Set video format (table E-2)",
423  { .i64 = -1 }, -1, 7, FLAGS },
424  { "video_full_range_flag", "Set video full range flag",
426  { .i64 = -1 }, -1, 1, FLAGS },
427  { "colour_primaries", "Set colour primaries (table E-3)",
429  { .i64 = -1 }, -1, 255, FLAGS },
430  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
432  { .i64 = -1 }, -1, 255, FLAGS },
433  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
435  { .i64 = -1 }, -1, 255, FLAGS },
436 
437  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
439  { .i64 = -1 }, -1, 6, FLAGS },
440 
441  { "tick_rate",
442  "Set VPS and VUI tick rate (num_units_in_tick / time_scale)",
444  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
445  { "num_ticks_poc_diff_one",
446  "Set VPS and VUI number of ticks per POC increment",
448  { .i64 = -1 }, -1, INT_MAX, FLAGS },
449 
450  { "crop_left", "Set left border crop offset",
452  { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
453  { "crop_right", "Set right border crop offset",
455  { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
456  { "crop_top", "Set top border crop offset",
458  { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
459  { "crop_bottom", "Set bottom border crop offset",
461  { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
462 
463  { "level", "Set level (tables A.6 and A.7)",
465  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
466  { "auto", "Attempt to guess level from stream properties",
468  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
469 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
470  { .i64 = value }, .flags = FLAGS, .unit = "level"
471  { LEVEL("1", 30) },
472  { LEVEL("2", 60) },
473  { LEVEL("2.1", 63) },
474  { LEVEL("3", 90) },
475  { LEVEL("3.1", 93) },
476  { LEVEL("4", 120) },
477  { LEVEL("4.1", 123) },
478  { LEVEL("5", 150) },
479  { LEVEL("5.1", 153) },
480  { LEVEL("5.2", 156) },
481  { LEVEL("6", 180) },
482  { LEVEL("6.1", 183) },
483  { LEVEL("6.2", 186) },
484  { LEVEL("8.5", 255) },
485 #undef LEVEL
486 
487  { NULL }
488 };
489 
490 static const AVClass h265_metadata_class = {
491  .class_name = "h265_metadata_bsf",
492  .item_name = av_default_item_name,
493  .option = h265_metadata_options,
494  .version = LIBAVUTIL_VERSION_INT,
495 };
496 
497 static const enum AVCodecID h265_metadata_codec_ids[] = {
499 };
500 
502  .name = "hevc_metadata",
503  .priv_data_size = sizeof(H265MetadataContext),
504  .priv_class = &h265_metadata_class,
506  .close = &ff_cbs_bsf_generic_close,
509 };
uint32_t bit_rate_value_minus1[HEVC_MAX_CPB_CNT]
Definition: cbs_h265.h:102
#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:150
uint8_t vps_poc_proportional_to_timing_flag
Definition: cbs_h265.h:217
AVOption.
Definition: opt.h:248
static void h265_metadata_update_level(AVBSFContext *bsf, uint8_t *level_idc)
H265RawHRDParameters hrd_parameters
Definition: cbs_h265.h:173
const char * desc
Definition: libsvtav1.c:79
uint8_t nal_hrd_parameters_present_flag
Definition: cbs_h265.h:110
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
enum AVCodecID codec_id
Definition: cbs_bsf.h:26
uint8_t vui_timing_info_present_flag
Definition: cbs_h265.h:167
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
static int h265_metadata_update_fragment(AVBSFContext *bsf, AVPacket *pkt, CodedBitstreamFragment *au)
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:385
uint8_t bit_rate_scale
Definition: cbs_h265.h:119
H265RawProfileTierLevel profile_tier_level
Definition: cbs_h265.h:261
static AVPacket pkt
uint8_t vui_parameters_present_flag
Definition: cbs_h265.h:319
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:70
int ff_cbs_bsf_generic_init(AVBSFContext *bsf, const CBSBSFType *type)
Initialise generic CBS BSF setup.
Definition: cbs_bsf.c:112
#define BSF_ELEMENT_OPTIONS_PIR(name, help, field, opt_flags)
Definition: cbs_bsf.h:106
uint32_t vps_num_units_in_tick
Definition: cbs_h265.h:215
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)
static const CBSBSFType h265_metadata_type
int tile_cols
Definition: h265_levels.c:218
uint16_t pic_height_in_luma_samples
Definition: cbs_h265.h:269
#define OFFSET(x)
uint8_t
H265RawSubLayerHRDParameters nal_sub_layer_hrd_parameters[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:132
static const AVOption h265_metadata_options[]
AVOptions.
uint8_t colour_primaries
Definition: cbs_h265.h:149
uint8_t video_format
Definition: cbs_h265.h:146
uint8_t vps_timing_info_present_flag
Definition: cbs_h265.h:214
int level_idc
Definition: h264_levels.c:25
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:151
uint8_t aspect_ratio_info_present_flag
Definition: cbs_h265.h:137
uint8_t nuh_temporal_id_plus1
Definition: cbs_h265.h:41
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:147
#define av_log(a,...)
uint8_t chroma_sample_loc_type_bottom_field
Definition: cbs_h265.h:155
uint8_t video_signal_type_present_flag
Definition: cbs_h265.h:145
H265RawVUI vui
Definition: cbs_h265.h:320
uint32_t vui_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:171
uint8_t vps_max_dec_pic_buffering_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:206
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:40
uint8_t chroma_loc_info_present_flag
Definition: cbs_h265.h:153
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
void ff_cbs_bsf_generic_close(AVBSFContext *bsf)
Close a generic CBS BSF instance.
Definition: cbs_bsf.c:152
uint16_t sar_height
Definition: cbs_h265.h:140
#define LEVEL(name, value)
uint8_t chroma_sample_loc_type_top_field
Definition: cbs_h265.h:154
uint32_t vui_time_scale
Definition: cbs_h265.h:169
H265RawHRDParameters hrd_parameters[HEVC_MAX_LAYER_SETS]
Definition: cbs_h265.h:222
H265RawNALUnitHeader nal_unit_header
Definition: cbs_h265.h:447
uint8_t slice_type
Definition: cbs_h265.h:463
H265RawProfileTierLevel profile_tier_level
Definition: cbs_h265.h:203
uint8_t pic_type
Definition: cbs_h265.h:449
uint16_t sar_width
Definition: cbs_h265.h:139
#define width
uint8_t vui_hrd_parameters_present_flag
Definition: cbs_h265.h:172
AVFormatContext * ctx
Definition: movenc.c:48
int ff_cbs_bsf_generic_filter(AVBSFContext *bsf, AVPacket *pkt)
Filter operation for CBS BSF.
Definition: cbs_bsf.c:63
uint16_t pic_width_in_luma_samples
Definition: cbs_h265.h:268
static int h265_metadata_init(AVBSFContext *bsf)
uint8_t vcl_hrd_parameters_present_flag
Definition: cbs_h265.h:111
H265RawSubLayerHRDParameters vcl_sub_layer_hrd_parameters[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:133
int tile_rows
Definition: h265_levels.c:217
#define FF_ARRAY_ELEMS(a)
uint16_t vps_num_hrd_parameters
Definition: cbs_h265.h:219
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.
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:118
uint8_t general_level_idc
Definition: cbs_h265.h:69
uint32_t vui_num_units_in_tick
Definition: cbs_h265.h:168
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
Describe the class of an AVClass context structure.
Definition: log.h:67
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
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:812
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:737
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
uint8_t chroma_format_idc
Definition: cbs_h265.h:265
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:170
const AVBitStreamFilter ff_hevc_metadata_bsf
common internal and external API header
uint8_t num_tile_rows_minus1
Definition: cbs_h265.h:389
static enum AVCodecID codec_ids[]
uint8_t num_tile_columns_minus1
Definition: cbs_h265.h:388
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:543
uint32_t vps_time_scale
Definition: cbs_h265.h:216
uint8_t aspect_ratio_idc
Definition: cbs_h265.h:138
uint8_t sps_max_dec_pic_buffering_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:283
AVRational sample_aspect_ratio
uint32_t vps_num_ticks_poc_diff_one_minus1
Definition: cbs_h265.h:218
uint8_t separate_colour_plane_flag
Definition: cbs_h265.h:266
uint8_t colour_description_present_flag
Definition: cbs_h265.h:148
#define FLAGS
This structure stores compressed data.
Definition: packet.h:340
int i
Definition: input.c:407
uint8_t nal_unit_type
Definition: cbs_h265.h:39