FFmpeg
h265_metadata.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_bsf.h"
26 #include "cbs_h265.h"
27 #include "h2645data.h"
28 #include "h265_profile_level.h"
29 
30 #include "hevc/hevc.h"
31 
32 enum {
34  LEVEL_AUTO = -1,
35 };
36 
37 typedef struct H265MetadataContext {
39 
41 
42  int aud;
43 
45 
51 
53 
57 
58  int crop_left;
60  int crop_top;
62  int width;
63  int height;
64 
65  int level;
69 
70 
72  const CodedBitstreamFragment *au)
73 {
77  const H265RawHRDParameters *hrd = NULL;
78  int64_t bit_rate = 0;
79  int width = 0, height = 0;
80  int tile_cols = 0, tile_rows = 0;
81  int max_dec_pic_buffering = 0;
82  int i;
83 
84  for (i = 0; i < au->nb_units; i++) {
85  const CodedBitstreamUnit *unit = &au->units[i];
86 
87  if (unit->type == HEVC_NAL_VPS) {
88  const H265RawVPS *vps = unit->content;
89 
90  ptl = &vps->profile_tier_level;
91  max_dec_pic_buffering = vps->vps_max_dec_pic_buffering_minus1[0] + 1;
92 
93  if (vps->vps_num_hrd_parameters > 0)
94  hrd = &vps->hrd_parameters[0];
95 
96  } else if (unit->type == HEVC_NAL_SPS) {
97  const H265RawSPS *sps = unit->content;
98 
99  ptl = &sps->profile_tier_level;
100  max_dec_pic_buffering = sps->sps_max_dec_pic_buffering_minus1[0] + 1;
101 
102  width = sps->pic_width_in_luma_samples;
103  height = sps->pic_height_in_luma_samples;
104 
105  if (sps->vui.vui_hrd_parameters_present_flag)
106  hrd = &sps->vui.hrd_parameters;
107 
108  } else if (unit->type == HEVC_NAL_PPS) {
109  const H265RawPPS *pps = unit->content;
110 
111  if (pps->tiles_enabled_flag) {
112  tile_cols = pps->num_tile_columns_minus1 + 1;
113  tile_rows = pps->num_tile_rows_minus1 + 1;
114  }
115  }
116  }
117 
118  if (hrd) {
120  bit_rate = (hrd->nal_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *
121  (INT64_C(1) << hrd->bit_rate_scale + 6);
122  } else if (hrd->vcl_hrd_parameters_present_flag) {
123  bit_rate = (hrd->vcl_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *
124  (INT64_C(1) << hrd->bit_rate_scale + 6);
125  // Adjust for VCL vs. NAL limits.
126  bit_rate = bit_rate * 11 / 10;
127  }
128  }
129 
130  desc = ff_h265_guess_level(ptl, bit_rate, width, height,
131  0, tile_rows, tile_cols,
132  max_dec_pic_buffering);
133  if (desc) {
134  av_log(bsf, AV_LOG_DEBUG, "Stream appears to conform to "
135  "level %s.\n", desc->name);
136  ctx->level_guess = desc->level_idc;
137  }
138 }
139 
141  uint8_t *level_idc)
142 {
144 
145  if (ctx->level != LEVEL_UNSET) {
146  if (ctx->level == LEVEL_AUTO) {
147  if (ctx->level_guess) {
148  *level_idc = ctx->level_guess;
149  } else {
150  if (!ctx->level_warned) {
151  av_log(bsf, AV_LOG_WARNING, "Unable to determine level "
152  "of stream: using level 8.5.\n");
153  ctx->level_warned = 1;
154  }
155  *level_idc = 255;
156  }
157  } else {
158  *level_idc = ctx->level;
159  }
160  }
161 }
162 
164  H265RawVPS *vps)
165 {
167 
168  if (ctx->tick_rate.num && ctx->tick_rate.den) {
169  int num, den;
170 
171  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
172  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
173 
174  vps->vps_time_scale = num;
175  vps->vps_num_units_in_tick = den;
176 
177  vps->vps_timing_info_present_flag = 1;
178 
179  if (ctx->num_ticks_poc_diff_one > 0) {
180  vps->vps_num_ticks_poc_diff_one_minus1 =
181  ctx->num_ticks_poc_diff_one - 1;
182  vps->vps_poc_proportional_to_timing_flag = 1;
183  } else if (ctx->num_ticks_poc_diff_one == 0) {
184  vps->vps_poc_proportional_to_timing_flag = 0;
185  }
186  }
187 
188  h265_metadata_update_level(bsf, &vps->profile_tier_level.general_level_idc);
189 
190  return 0;
191 }
192 
194  int *crop_left, int *crop_right,
195  int *crop_top, int *crop_bottom)
196 {
197  const H265MetadataContext *ctx = bsf->priv_data;
198  int left = ctx->crop_left;
199  int right = ctx->crop_right;
200  int top = ctx->crop_top;
201  int bottom = ctx->crop_bottom;
202 
203  if (ctx->width > 0) {
204  if (ctx->width > sps->pic_width_in_luma_samples) {
205  av_log(bsf, AV_LOG_ERROR,
206  "The width option value %d is larger than picture width %d\n",
207  ctx->width, sps->pic_width_in_luma_samples);
208  return AVERROR(EINVAL);
209  }
210 
211  if (left < 0) {
212  if (right > 0)
213  left = sps->pic_width_in_luma_samples - ctx->width - right;
214  else
215  left = 0;
216  }
217 
218  if (right < 0)
219  right = sps->pic_width_in_luma_samples - ctx->width - left;
220 
221  if (left < 0 || right < 0 || (left + right + ctx->width) !=
222  sps->pic_width_in_luma_samples) {
223  av_log(bsf, AV_LOG_ERROR,
224  "Invalid value for crop_left %d, crop_right %d, width after "
225  "crop %d, with picture width %d\n",
226  ctx->crop_left, ctx->crop_right, ctx->width,
227  sps->pic_width_in_luma_samples);
228  return AVERROR(EINVAL);
229  }
230  }
231 
232  if (ctx->height > 0) {
233  if (ctx->height > sps->pic_height_in_luma_samples) {
234  av_log(bsf, AV_LOG_ERROR,
235  "The height option value %d is larger than picture height %d\n",
236  ctx->height, sps->pic_height_in_luma_samples);
237  return AVERROR(EINVAL);
238  }
239 
240  if (top < 0) {
241  if (bottom > 0)
242  top = sps->pic_height_in_luma_samples - ctx->height - bottom;
243  else
244  top = 0;
245  }
246 
247  if (bottom < 0)
248  bottom = sps->pic_height_in_luma_samples - ctx->height - top;
249 
250  if (top < 0 || bottom < 0 || (top + bottom + ctx->height) !=
251  sps->pic_height_in_luma_samples) {
252  av_log(bsf, AV_LOG_ERROR,
253  "Invalid value for crop_top %d, crop_bottom %d, height after "
254  "crop %d, with picture height %d\n",
255  ctx->crop_top, ctx->crop_bottom, ctx->height,
256  sps->pic_height_in_luma_samples);
257  return AVERROR(EINVAL);
258  }
259  }
260 
261  *crop_left = left;
262  *crop_right = right;
263  *crop_top = top;
264  *crop_bottom = bottom;
265 
266  return 0;
267 }
268 
270  H265RawSPS *sps)
271 {
273  int need_vui = 0;
274  int crop_unit_x, crop_unit_y;
275  /* Use local variables to avoid modifying context fields in case of video
276  * resolution changed. Crop doesn't work well with resolution change, this
277  * is the best we can do.
278  */
279  int crop_left, crop_right, crop_top, crop_bottom;
280  int ret;
281 
282  if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
283  int num, den, i;
284 
285  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
286  ctx->sample_aspect_ratio.den, 65535);
287 
288  for (i = 1; i < FF_ARRAY_ELEMS(ff_h2645_pixel_aspect); i++) {
289  if (num == ff_h2645_pixel_aspect[i].num &&
290  den == ff_h2645_pixel_aspect[i].den)
291  break;
292  }
294  sps->vui.aspect_ratio_idc = 255;
295  sps->vui.sar_width = num;
296  sps->vui.sar_height = den;
297  } else {
298  sps->vui.aspect_ratio_idc = i;
299  }
300  sps->vui.aspect_ratio_info_present_flag = 1;
301  need_vui = 1;
302  }
303 
304 #define SET_OR_INFER(field, value, present_flag, infer) do { \
305  if (value >= 0) { \
306  field = value; \
307  need_vui = 1; \
308  } else if (!present_flag) \
309  field = infer; \
310  } while (0)
311 
312  if (ctx->video_format >= 0 ||
313  ctx->video_full_range_flag >= 0 ||
314  ctx->colour_primaries >= 0 ||
315  ctx->transfer_characteristics >= 0 ||
316  ctx->matrix_coefficients >= 0) {
317 
318  SET_OR_INFER(sps->vui.video_format, ctx->video_format,
319  sps->vui.video_signal_type_present_flag, 5);
320 
321  SET_OR_INFER(sps->vui.video_full_range_flag,
322  ctx->video_full_range_flag,
323  sps->vui.video_signal_type_present_flag, 0);
324 
325  if (ctx->colour_primaries >= 0 ||
326  ctx->transfer_characteristics >= 0 ||
327  ctx->matrix_coefficients >= 0) {
328 
329  SET_OR_INFER(sps->vui.colour_primaries,
330  ctx->colour_primaries,
331  sps->vui.colour_description_present_flag, 2);
332 
333  SET_OR_INFER(sps->vui.transfer_characteristics,
334  ctx->transfer_characteristics,
335  sps->vui.colour_description_present_flag, 2);
336 
337  SET_OR_INFER(sps->vui.matrix_coefficients,
338  ctx->matrix_coefficients,
339  sps->vui.colour_description_present_flag, 2);
340 
341  sps->vui.colour_description_present_flag = 1;
342  }
343  sps->vui.video_signal_type_present_flag = 1;
344  need_vui = 1;
345  }
346 
347  if (ctx->chroma_sample_loc_type >= 0) {
348  sps->vui.chroma_sample_loc_type_top_field =
349  ctx->chroma_sample_loc_type;
350  sps->vui.chroma_sample_loc_type_bottom_field =
351  ctx->chroma_sample_loc_type;
352  sps->vui.chroma_loc_info_present_flag = 1;
353  need_vui = 1;
354  }
355 
356  if (ctx->tick_rate.num && ctx->tick_rate.den) {
357  int num, den;
358 
359  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
360  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
361 
362  sps->vui.vui_time_scale = num;
363  sps->vui.vui_num_units_in_tick = den;
364 
365  sps->vui.vui_timing_info_present_flag = 1;
366  need_vui = 1;
367 
368  if (ctx->num_ticks_poc_diff_one > 0) {
369  sps->vui.vui_num_ticks_poc_diff_one_minus1 =
370  ctx->num_ticks_poc_diff_one - 1;
371  sps->vui.vui_poc_proportional_to_timing_flag = 1;
372  } else if (ctx->num_ticks_poc_diff_one == 0) {
373  sps->vui.vui_poc_proportional_to_timing_flag = 0;
374  }
375  }
376 
377  ret = h265_metadata_deduce_crop(bsf, sps, &crop_left, &crop_right,
378  &crop_top, &crop_bottom);
379  if (ret < 0)
380  return ret;
381 
382  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
383  crop_unit_x = 1;
384  crop_unit_y = 1;
385  } else {
386  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
387  crop_unit_y = 1 + (sps->chroma_format_idc < 2);
388  }
389 #define CROP(border, unit) do { \
390  if (crop_ ## border >= 0) { \
391  if (crop_ ## border % unit != 0) { \
392  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
393  "must be a multiple of %d.\n", #border, unit); \
394  return AVERROR(EINVAL); \
395  } \
396  sps->conf_win_ ## border ## _offset = \
397  crop_ ## border / unit; \
398  sps->conformance_window_flag = 1; \
399  } \
400  } while (0)
401  CROP(left, crop_unit_x);
402  CROP(right, crop_unit_x);
403  CROP(top, crop_unit_y);
404  CROP(bottom, crop_unit_y);
405 #undef CROP
406 
407  if (need_vui)
408  sps->vui_parameters_present_flag = 1;
409 
410  h265_metadata_update_level(bsf, &sps->profile_tier_level.general_level_idc);
411 
412  return 0;
413 }
414 
417 {
419  int err, i;
420 
421  // If an AUD is present, it must be the first NAL unit.
422  if (au->nb_units && au->units[0].type == HEVC_NAL_AUD) {
423  if (ctx->aud == BSF_ELEMENT_REMOVE)
424  ff_cbs_delete_unit(au, 0);
425  } else {
426  if (pkt && ctx->aud == BSF_ELEMENT_INSERT) {
427  H265RawAUD *aud = &ctx->aud_nal;
428  int pic_type = 0, temporal_id = 8, layer_id = 0;
429 
430  for (i = 0; i < au->nb_units; i++) {
431  const H265RawNALUnitHeader *nal = au->units[i].content;
432  if (!nal)
433  continue;
434  if (nal->nuh_temporal_id_plus1 < temporal_id + 1)
435  temporal_id = nal->nuh_temporal_id_plus1 - 1;
436 
437  if (au->units[i].type <= HEVC_NAL_RSV_VCL31) {
438  const H265RawSlice *slice = au->units[i].content;
439  layer_id = nal->nuh_layer_id;
440  if (slice->header.slice_type == HEVC_SLICE_B &&
441  pic_type < 2)
442  pic_type = 2;
443  if (slice->header.slice_type == HEVC_SLICE_P &&
444  pic_type < 1)
445  pic_type = 1;
446  }
447  }
448 
449  aud->nal_unit_header = (H265RawNALUnitHeader) {
450  .nal_unit_type = HEVC_NAL_AUD,
451  .nuh_layer_id = layer_id,
452  .nuh_temporal_id_plus1 = temporal_id + 1,
453  };
454  aud->pic_type = pic_type;
455 
457  if (err < 0) {
458  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
459  return err;
460  }
461  }
462  }
463 
464  if (ctx->level == LEVEL_AUTO && !ctx->level_guess)
465  h265_metadata_guess_level(bsf, au);
466 
467  for (i = 0; i < au->nb_units; i++) {
468  if (au->units[i].type == HEVC_NAL_VPS) {
469  err = h265_metadata_update_vps(bsf, au->units[i].content);
470  if (err < 0)
471  return err;
472  }
473  if (au->units[i].type == HEVC_NAL_SPS) {
474  err = h265_metadata_update_sps(bsf, au->units[i].content);
475  if (err < 0)
476  return err;
477  }
478  }
479 
480  return 0;
481 }
482 
485  .fragment_name = "access unit",
486  .unit_name = "NAL unit",
487  .update_fragment = &h265_metadata_update_fragment,
488 };
489 
491 {
493 }
494 
495 #define OFFSET(x) offsetof(H265MetadataContext, x)
496 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
497 static const AVOption h265_metadata_options[] = {
498  BSF_ELEMENT_OPTIONS_PIR("aud", "Access Unit Delimiter NAL units",
499  aud, FLAGS),
500 
501  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
502  OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
503  { .dbl = 0.0 }, 0, 65535, FLAGS },
504 
505  { "video_format", "Set video format (table E-2)",
506  OFFSET(video_format), AV_OPT_TYPE_INT,
507  { .i64 = -1 }, -1, 7, FLAGS },
508  { "video_full_range_flag", "Set video full range flag",
509  OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
510  { .i64 = -1 }, -1, 1, FLAGS },
511  { "colour_primaries", "Set colour primaries (table E-3)",
512  OFFSET(colour_primaries), AV_OPT_TYPE_INT,
513  { .i64 = -1 }, -1, 255, FLAGS },
514  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
516  { .i64 = -1 }, -1, 255, FLAGS },
517  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
518  OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
519  { .i64 = -1 }, -1, 255, FLAGS },
520 
521  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
522  OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
523  { .i64 = -1 }, -1, 5, FLAGS },
524 
525  { "tick_rate",
526  "Set VPS and VUI tick rate (time_scale / num_units_in_tick)",
527  OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
528  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
529  { "num_ticks_poc_diff_one",
530  "Set VPS and VUI number of ticks per POC increment",
531  OFFSET(num_ticks_poc_diff_one), AV_OPT_TYPE_INT,
532  { .i64 = -1 }, -1, INT_MAX, FLAGS },
533 
534  { "crop_left", "Set left border crop offset",
535  OFFSET(crop_left), AV_OPT_TYPE_INT,
536  { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
537  { "crop_right", "Set right border crop offset",
538  OFFSET(crop_right), AV_OPT_TYPE_INT,
539  { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
540  { "crop_top", "Set top border crop offset",
541  OFFSET(crop_top), AV_OPT_TYPE_INT,
542  { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
543  { "crop_bottom", "Set bottom border crop offset",
544  OFFSET(crop_bottom), AV_OPT_TYPE_INT,
545  { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
546  { "width", "Set width after crop",
548  { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },
549  { "height", "Set height after crop",
551  { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },
552 
553  { "level", "Set level (tables A.6 and A.7)",
555  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, .unit = "level" },
556  { "auto", "Attempt to guess level from stream properties",
558  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
559 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
560  { .i64 = value }, .flags = FLAGS, .unit = "level"
561  { LEVEL("1", 30) },
562  { LEVEL("2", 60) },
563  { LEVEL("2.1", 63) },
564  { LEVEL("3", 90) },
565  { LEVEL("3.1", 93) },
566  { LEVEL("4", 120) },
567  { LEVEL("4.1", 123) },
568  { LEVEL("5", 150) },
569  { LEVEL("5.1", 153) },
570  { LEVEL("5.2", 156) },
571  { LEVEL("6", 180) },
572  { LEVEL("6.1", 183) },
573  { LEVEL("6.2", 186) },
574  { LEVEL("8.5", 255) },
575 #undef LEVEL
576 
577  { NULL }
578 };
579 
580 static const AVClass h265_metadata_class = {
581  .class_name = "h265_metadata_bsf",
582  .item_name = av_default_item_name,
583  .option = h265_metadata_options,
584  .version = LIBAVUTIL_VERSION_INT,
585 };
586 
587 static const enum AVCodecID h265_metadata_codec_ids[] = {
589 };
590 
592  .p.name = "hevc_metadata",
593  .p.codec_ids = h265_metadata_codec_ids,
594  .p.priv_class = &h265_metadata_class,
595  .priv_data_size = sizeof(H265MetadataContext),
597  .close = &ff_cbs_bsf_generic_close,
599 };
HEVC_NAL_AUD
@ HEVC_NAL_AUD
Definition: hevc.h:64
H265MetadataContext::crop_bottom
int crop_bottom
Definition: h265_metadata.c:61
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
level
uint8_t level
Definition: svq3.c:205
ff_cbs_bsf_generic_init
int ff_cbs_bsf_generic_init(AVBSFContext *bsf, const CBSBSFType *type)
Initialise generic CBS BSF setup.
Definition: cbs_bsf.c:110
AVERROR
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
bsf_internal.h
opt.h
H265MetadataContext::chroma_sample_loc_type
int chroma_sample_loc_type
Definition: h265_metadata.c:52
H265RawSubLayerHRDParameters::bit_rate_value_minus1
uint32_t bit_rate_value_minus1[HEVC_MAX_CPB_CNT]
Definition: cbs_h265.h:94
CBSBSFType::codec_id
enum AVCodecID codec_id
Definition: cbs_bsf.h:32
H265MetadataContext::transfer_characteristics
int transfer_characteristics
Definition: h265_metadata.c:49
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:107
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, void *content_ref)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:783
int64_t
long long int64_t
Definition: coverity.c:34
H265RawSlice::header
H265RawSliceHeader header
Definition: cbs_h265.h:535
LEVEL
#define LEVEL(name, value)
h265_metadata_options
static const AVOption h265_metadata_options[]
Definition: h265_metadata.c:497
level_idc
int level_idc
Definition: h264_levels.c:29
AVOption
AVOption.
Definition: opt.h:357
H265RawNALUnitHeader::nuh_temporal_id_plus1
uint8_t nuh_temporal_id_plus1
Definition: cbs_h265.h:33
CBSBSFContext
Definition: cbs_bsf.h:53
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:74
cbs.h
cbs_h265.h
HEVC_MAX_HEIGHT
@ HEVC_MAX_HEIGHT
Definition: hevc.h:139
H265MetadataContext::matrix_coefficients
int matrix_coefficients
Definition: h265_metadata.c:50
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:250
H265MetadataContext::aud_nal
H265RawAUD aud_nal
Definition: h265_metadata.c:40
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:70
H265LevelDescriptor
Definition: h265_profile_level.h:27
H265RawSPS
Definition: cbs_h265.h:245
H265RawVPS
Definition: cbs_h265.h:184
HEVC_MAX_WIDTH
@ HEVC_MAX_WIDTH
Definition: hevc.h:138
H265RawPPS
Definition: cbs_h265.h:347
LEVEL_AUTO
@ LEVEL_AUTO
Definition: h265_metadata.c:34
bsf.h
cbs_bsf.h
H265RawHRDParameters::vcl_hrd_parameters_present_flag
uint8_t vcl_hrd_parameters_present_flag
Definition: cbs_h265.h:103
H265MetadataContext::level
int level
Definition: h265_metadata.c:65
H265MetadataContext::crop_left
int crop_left
Definition: h265_metadata.c:58
av_reduce
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
h265_metadata_guess_level
static void h265_metadata_guess_level(AVBSFContext *bsf, const CodedBitstreamFragment *au)
Definition: h265_metadata.c:71
CodedBitstreamFragment::units
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:168
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ptl
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
ff_h265_guess_level
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.
Definition: h265_profile_level.c:162
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:122
width
#define width
H265MetadataContext::video_full_range_flag
int video_full_range_flag
Definition: h265_metadata.c:47
HEVC_NAL_VPS
@ HEVC_NAL_VPS
Definition: hevc.h:61
tile_rows
int tile_rows
Definition: h265_levels.c:217
H265RawHRDParameters::bit_rate_scale
uint8_t bit_rate_scale
Definition: cbs_h265.h:111
tile_cols
int tile_cols
Definition: av1_levels.c:73
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
hevc.h
h265_metadata_update_fragment
static int h265_metadata_update_fragment(AVBSFContext *bsf, AVPacket *pkt, CodedBitstreamFragment *au)
Definition: h265_metadata.c:415
h2645data.h
H265MetadataContext::common
CBSBSFContext common
Definition: h265_metadata.c:38
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
H265RawAUD
Definition: cbs_h265.h:438
FFBitStreamFilter
Definition: bsf_internal.h:27
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
h265_metadata_update_vps
static int h265_metadata_update_vps(AVBSFContext *bsf, H265RawVPS *vps)
Definition: h265_metadata.c:163
H265MetadataContext::level_warned
int level_warned
Definition: h265_metadata.c:67
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
HEVC_NAL_RSV_VCL31
@ HEVC_NAL_RSV_VCL31
Definition: hevc.h:60
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:423
H265RawSliceHeader::slice_type
uint8_t slice_type
Definition: cbs_h265.h:455
BSF_ELEMENT_REMOVE
@ BSF_ELEMENT_REMOVE
Definition: cbs_bsf.h:106
H265RawNALUnitHeader
Definition: cbs_h265.h:30
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
H265MetadataContext::level_guess
int level_guess
Definition: h265_metadata.c:66
OFFSET
#define OFFSET(x)
Definition: h265_metadata.c:495
FFBitStreamFilter::p
AVBitStreamFilter p
The public AVBitStreamFilter.
Definition: bsf_internal.h:31
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:875
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
CBSBSFType
Definition: cbs_bsf.h:31
HEVC_NAL_SPS
@ HEVC_NAL_SPS
Definition: hevc.h:62
ff_cbs_bsf_generic_close
void ff_cbs_bsf_generic_close(AVBSFContext *bsf)
Close a generic CBS BSF instance.
Definition: cbs_bsf.c:155
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:166
h265_profile_level.h
H265RawHRDParameters
Definition: cbs_h265.h:101
HEVC_NAL_PPS
@ HEVC_NAL_PPS
Definition: hevc.h:63
height
#define height
H265MetadataContext
Definition: h265_metadata.c:37
H265MetadataContext::tick_rate
AVRational tick_rate
Definition: h265_metadata.c:54
H265RawNALUnitHeader::nuh_layer_id
uint8_t nuh_layer_id
Definition: cbs_h265.h:32
H265MetadataContext::poc_proportional_to_timing_flag
int poc_proportional_to_timing_flag
Definition: h265_metadata.c:55
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
SET_OR_INFER
#define SET_OR_INFER(field, value, present_flag, infer)
FLAGS
#define FLAGS
Definition: h265_metadata.c:496
common.h
H265MetadataContext::video_format
int video_format
Definition: h265_metadata.c:46
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
h265_metadata_codec_ids
static enum AVCodecID h265_metadata_codec_ids[]
Definition: h265_metadata.c:587
ff_h2645_pixel_aspect
const AVRational ff_h2645_pixel_aspect[]
Definition: h2645data.c:21
H265RawProfileTierLevel
Definition: cbs_h265.h:36
H265RawHRDParameters::nal_hrd_parameters_present_flag
uint8_t nal_hrd_parameters_present_flag
Definition: cbs_h265.h:102
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:83
ff_cbs_bsf_generic_filter
int ff_cbs_bsf_generic_filter(AVBSFContext *bsf, AVPacket *pkt)
Filter operation for CBS BSF.
Definition: cbs_bsf.c:61
ret
ret
Definition: filter_design.txt:187
H265MetadataContext::colour_primaries
int colour_primaries
Definition: h265_metadata.c:48
AVClass::class_name
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:71
h265_metadata_type
static const CBSBSFType h265_metadata_type
Definition: h265_metadata.c:483
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
h265_metadata_update_level
static void h265_metadata_update_level(AVBSFContext *bsf, uint8_t *level_idc)
Definition: h265_metadata.c:140
BSF_ELEMENT_OPTIONS_PIR
#define BSF_ELEMENT_OPTIONS_PIR(name, help, field, opt_flags)
Definition: cbs_bsf.h:112
LEVEL_UNSET
@ LEVEL_UNSET
Definition: h265_metadata.c:33
H265MetadataContext::height
int height
Definition: h265_metadata.c:63
h265_metadata_init
static int h265_metadata_init(AVBSFContext *bsf)
Definition: h265_metadata.c:490
left
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:386
h265_metadata_update_sps
static int h265_metadata_update_sps(AVBSFContext *bsf, H265RawSPS *sps)
Definition: h265_metadata.c:269
CROP
#define CROP(border, unit)
H265MetadataContext::crop_top
int crop_top
Definition: h265_metadata.c:60
H265RawHRDParameters::vcl_sub_layer_hrd_parameters
H265RawSubLayerHRDParameters vcl_sub_layer_hrd_parameters[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:125
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
H265MetadataContext::width
int width
Definition: h265_metadata.c:62
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
H265MetadataContext::crop_right
int crop_right
Definition: h265_metadata.c:59
desc
const char * desc
Definition: libsvtav1.c:79
h265_metadata_class
static const AVClass h265_metadata_class
Definition: h265_metadata.c:580
ff_hevc_metadata_bsf
const FFBitStreamFilter ff_hevc_metadata_bsf
Definition: h265_metadata.c:591
AVPacket
This structure stores compressed data.
Definition: packet.h:510
BSF_ELEMENT_INSERT
@ BSF_ELEMENT_INSERT
Definition: cbs_bsf.h:104
H265RawHRDParameters::nal_sub_layer_hrd_parameters
H265RawSubLayerHRDParameters nal_sub_layer_hrd_parameters[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:124
h265_metadata_deduce_crop
static int h265_metadata_deduce_crop(AVBSFContext *bsf, const H265RawSPS *sps, int *crop_left, int *crop_right, int *crop_top, int *crop_bottom)
Definition: h265_metadata.c:193
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
H265MetadataContext::num_ticks_poc_diff_one
int num_ticks_poc_diff_one
Definition: h265_metadata.c:56
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
H265MetadataContext::sample_aspect_ratio
AVRational sample_aspect_ratio
Definition: h265_metadata.c:44
CodedBitstreamFragment::nb_units
int nb_units
Number of units in this fragment.
Definition: cbs.h:153
ff_cbs_delete_unit
void ff_cbs_delete_unit(CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
Definition: cbs.c:860
H265RawSlice
Definition: cbs_h265.h:534
HEVC_SLICE_P
@ HEVC_SLICE_P
Definition: hevc.h:97
H265MetadataContext::aud
int aud
Definition: h265_metadata.c:42