FFmpeg: libavcodec/h2645_sei.c Source File

FFmpeg
h2645_sei.c
Go to the documentation of this file.
1 /*
2  * Common H.264 and HEVC Supplementary Enhancement Information messages
3  *
4  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5  * Copyright (C) 2012 - 2013 Guillaume Martres
6  * Copyright (C) 2012 - 2013 Gildas Cocherel
7  * Copyright (C) 2013 Vittorio Giovara
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include "config_components.h"
27 
28 #include "libavutil/ambient_viewing_environment.h"
29 #include "libavutil/display.h"
30 #include "libavutil/film_grain_params.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/stereo3d.h"
33 
34 #include "atsc_a53.h"
35 #include "avcodec.h"
36 #include "dynamic_hdr10_plus.h"
37 #include "dynamic_hdr_vivid.h"
38 #include "get_bits.h"
39 #include "golomb.h"
40 #include "h2645_sei.h"
41 
42  #define IS_H264(codec_id) (CONFIG_H264_SEI && CONFIG_HEVC_SEI ? codec_id == AV_CODEC_ID_H264 : CONFIG_H264_SEI)
43  #define IS_HEVC(codec_id) (CONFIG_H264_SEI && CONFIG_HEVC_SEI ? codec_id == AV_CODEC_ID_HEVC : CONFIG_HEVC_SEI)
44 
45 #if CONFIG_HEVC_SEI
46 static int decode_registered_user_data_dynamic_hdr_plus(HEVCSEIDynamicHDRPlus *s,
47  GetByteContext *gb)
48 {
49  size_t meta_size;
50  int err;
51  AVDynamicHDRPlus *metadata = av_dynamic_hdr_plus_alloc(&meta_size);
52  if (!metadata)
53  return AVERROR(ENOMEM);
54 
55  err = ff_parse_itu_t_t35_to_dynamic_hdr10_plus(metadata, gb->buffer,
56  bytestream2_get_bytes_left(gb));
57  if (err < 0) {
58  av_free(metadata);
59  return err;
60  }
61 
62  av_buffer_unref(&s->info);
63  s->info = av_buffer_create((uint8_t *)metadata, meta_size, NULL, NULL, 0);
64  if (!s->info) {
65  av_free(metadata);
66  return AVERROR(ENOMEM);
67  }
68 
69  return 0;
70 }
71 
72 static int decode_registered_user_data_dynamic_hdr_vivid(HEVCSEIDynamicHDRVivid *s,
73  GetByteContext *gb)
74 {
75  size_t meta_size;
76  int err;
77  AVDynamicHDRVivid *metadata = av_dynamic_hdr_vivid_alloc(&meta_size);
78  if (!metadata)
79  return AVERROR(ENOMEM);
80 
81  err = ff_parse_itu_t_t35_to_dynamic_hdr_vivid(metadata,
82  gb->buffer, bytestream2_get_bytes_left(gb));
83  if (err < 0) {
84  av_free(metadata);
85  return err;
86  }
87 
88  av_buffer_unref(&s->info);
89  s->info = av_buffer_create((uint8_t *)metadata, meta_size, NULL, NULL, 0);
90  if (!s->info) {
91  av_free(metadata);
92  return AVERROR(ENOMEM);
93  }
94 
95  return 0;
96 }
97 #endif
98 
99  static int decode_registered_user_data_afd(H2645SEIAFD *h, GetByteContext *gb)
100 {
101  int flag;
102 
103  if (bytestream2_get_bytes_left(gb) <= 0)
104  return AVERROR_INVALIDDATA;
105 
106  flag = !!(bytestream2_get_byteu(gb) & 0x40); // active_format_flag
107 
108  if (flag) {
109  if (bytestream2_get_bytes_left(gb) <= 0)
110  return AVERROR_INVALIDDATA;
111  h->active_format_description = bytestream2_get_byteu(gb) & 0xF;
112  h->present = 1;
113  }
114 
115  return 0;
116 }
117 
118  static int decode_registered_user_data_closed_caption(H2645SEIA53Caption *h,
119  GetByteContext *gb)
120 {
121  return ff_parse_a53_cc(&h->buf_ref, gb->buffer,
122  bytestream2_get_bytes_left(gb));
123 }
124 
125  static int decode_registered_user_data(H2645SEI *h, GetByteContext *gb,
126  enum AVCodecID codec_id, void *logctx)
127 {
128  int country_code, provider_code;
129 
130  if (bytestream2_get_bytes_left(gb) < 3)
131  return AVERROR_INVALIDDATA;
132 
133  country_code = bytestream2_get_byteu(gb); // itu_t_t35_country_code
134  if (country_code == 0xFF) {
135  if (bytestream2_get_bytes_left(gb) < 3)
136  return AVERROR_INVALIDDATA;
137 
138  bytestream2_skipu(gb, 1); // itu_t_t35_country_code_extension_byte
139  }
140 
141  if (country_code != 0xB5 && country_code != 0x26) { // usa_country_code and cn_country_code
142  av_log(logctx, AV_LOG_VERBOSE,
143  "Unsupported User Data Registered ITU-T T35 SEI message (country_code = %d)\n",
144  country_code);
145  return 0;
146  }
147 
148  /* itu_t_t35_payload_byte follows */
149  provider_code = bytestream2_get_be16u(gb);
150 
151  switch (provider_code) {
152  case 0x31: { // atsc_provider_code
153  uint32_t user_identifier;
154 
155  if (bytestream2_get_bytes_left(gb) < 4)
156  return AVERROR_INVALIDDATA;
157 
158  user_identifier = bytestream2_get_be32u(gb);
159  switch (user_identifier) {
160  case MKBETAG('D', 'T', 'G', '1'): // afd_data
161  return decode_registered_user_data_afd(&h->afd, gb);
162  case MKBETAG('G', 'A', '9', '4'): // closed captions
163  return decode_registered_user_data_closed_caption(&h->a53_caption, gb);
164  default:
165  av_log(logctx, AV_LOG_VERBOSE,
166  "Unsupported User Data Registered ITU-T T35 SEI message (atsc user_identifier = 0x%04x)\n",
167  user_identifier);
168  break;
169  }
170  break;
171  }
172 #if CONFIG_HEVC_SEI
173  case 0x04: { // cuva_provider_code
174  const uint16_t cuva_provider_oriented_code = 0x0005;
175  uint16_t provider_oriented_code;
176 
177  if (!IS_HEVC(codec_id))
178  goto unsupported_provider_code;
179 
180  if (bytestream2_get_bytes_left(gb) < 2)
181  return AVERROR_INVALIDDATA;
182 
183  provider_oriented_code = bytestream2_get_be16u(gb);
184  if (provider_oriented_code == cuva_provider_oriented_code) {
185  return decode_registered_user_data_dynamic_hdr_vivid(&h->dynamic_hdr_vivid, gb);
186  }
187  break;
188  }
189  case 0x3C: { // smpte_provider_code
190  // A/341 Amendment - 2094-40
191  const uint16_t smpte2094_40_provider_oriented_code = 0x0001;
192  const uint8_t smpte2094_40_application_identifier = 0x04;
193  uint16_t provider_oriented_code;
194  uint8_t application_identifier;
195 
196  if (!IS_HEVC(codec_id))
197  goto unsupported_provider_code;
198 
199  if (bytestream2_get_bytes_left(gb) < 3)
200  return AVERROR_INVALIDDATA;
201 
202  provider_oriented_code = bytestream2_get_be16u(gb);
203  application_identifier = bytestream2_get_byteu(gb);
204  if (provider_oriented_code == smpte2094_40_provider_oriented_code &&
205  application_identifier == smpte2094_40_application_identifier) {
206  return decode_registered_user_data_dynamic_hdr_plus(&h->dynamic_hdr_plus, gb);
207  }
208  break;
209  }
210  unsupported_provider_code:
211 #endif
212  default:
213  av_log(logctx, AV_LOG_VERBOSE,
214  "Unsupported User Data Registered ITU-T T35 SEI message (provider_code = %d)\n",
215  provider_code);
216  break;
217  }
218 
219  return 0;
220 }
221 
222  static int decode_unregistered_user_data(H2645SEIUnregistered *h,
223  GetByteContext *gb,
224  enum AVCodecID codec_id)
225 {
226  uint8_t *user_data;
227  int size = bytestream2_get_bytes_left(gb);
228  AVBufferRef *buf_ref, **tmp;
229 
230  if (size < 16 || size >= INT_MAX - 1)
231  return AVERROR_INVALIDDATA;
232 
233  tmp = av_realloc_array(h->buf_ref, h->nb_buf_ref + 1, sizeof(*h->buf_ref));
234  if (!tmp)
235  return AVERROR(ENOMEM);
236  h->buf_ref = tmp;
237 
238  buf_ref = av_buffer_alloc(size + 1);
239  if (!buf_ref)
240  return AVERROR(ENOMEM);
241  user_data = buf_ref->data;
242 
243  bytestream2_get_bufferu(gb, user_data, size);
244  user_data[size] = 0;
245  buf_ref->size = size;
246  h->buf_ref[h->nb_buf_ref++] = buf_ref;
247 
248  if (IS_H264(codec_id)) {
249  int e, build;
250  e = sscanf(user_data + 16, "x264 - core %d", &build);
251  if (e == 1 && build > 0)
252  h->x264_build = build;
253  if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
254  h->x264_build = 67;
255  }
256 
257  return 0;
258 }
259 
260  static int decode_display_orientation(H2645SEIDisplayOrientation *h,
261  GetBitContext *gb)
262 {
263  h->present = !get_bits1(gb); // display_orientation_cancel_flag
264 
265  if (h->present) {
266  h->hflip = get_bits1(gb); // hor_flip
267  h->vflip = get_bits1(gb); // ver_flip
268 
269  h->anticlockwise_rotation = get_bits(gb, 16);
270  // This is followed by display_orientation_repetition_period
271  // and display_orientation_extension_flag for H.264
272  // and by display_orientation_persistence_flag for HEVC.
273  }
274 
275  return 0;
276 }
277 
278  static int decode_frame_packing_arrangement(H2645SEIFramePacking *h,
279  GetBitContext *gb,
280  enum AVCodecID codec_id)
281 {
282  h->arrangement_id = get_ue_golomb_long(gb);
283  h->arrangement_cancel_flag = get_bits1(gb);
284  h->present = !h->arrangement_cancel_flag;
285 
286  if (h->present) {
287  h->arrangement_type = get_bits(gb, 7);
288  h->quincunx_sampling_flag = get_bits1(gb);
289  h->content_interpretation_type = get_bits(gb, 6);
290 
291  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
292  skip_bits(gb, 3);
293  h->current_frame_is_frame0_flag = get_bits1(gb);
294  // frame0_self_contained_flag, frame1_self_contained_flag
295  skip_bits(gb, 2);
296 
297  if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
298  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
299  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
300  if (IS_H264(codec_id))
301  h->arrangement_repetition_period = get_ue_golomb_long(gb);
302  else
303  skip_bits1(gb); // frame_packing_arrangement_persistence_flag
304  }
305  // H.264: frame_packing_arrangement_extension_flag,
306  // HEVC: upsampled_aspect_ratio_flag
307  skip_bits1(gb);
308 
309  return 0;
310 }
311 
312  static int decode_alternative_transfer(H2645SEIAlternativeTransfer *s,
313  GetByteContext *gb)
314 {
315  if (bytestream2_get_bytes_left(gb) < 1)
316  return AVERROR_INVALIDDATA;
317 
318  s->present = 1;
319  s->preferred_transfer_characteristics = bytestream2_get_byteu(gb);
320 
321  return 0;
322 }
323 
324  static int decode_ambient_viewing_environment(H2645SEIAmbientViewingEnvironment *s,
325  GetByteContext *gb)
326 {
327  static const uint16_t max_ambient_light_value = 50000;
328 
329  if (bytestream2_get_bytes_left(gb) < 8)
330  return AVERROR_INVALIDDATA;
331 
332  s->ambient_illuminance = bytestream2_get_be32u(gb);
333  if (!s->ambient_illuminance)
334  return AVERROR_INVALIDDATA;
335 
336  s->ambient_light_x = bytestream2_get_be16u(gb);
337  if (s->ambient_light_x > max_ambient_light_value)
338  return AVERROR_INVALIDDATA;
339 
340  s->ambient_light_y = bytestream2_get_be16u(gb);
341  if (s->ambient_light_y > max_ambient_light_value)
342  return AVERROR_INVALIDDATA;
343 
344  s->present = 1;
345 
346  return 0;
347 }
348 
349  static int decode_film_grain_characteristics(H2645SEIFilmGrainCharacteristics *h,
350  enum AVCodecID codec_id, GetBitContext *gb)
351 {
352  h->present = !get_bits1(gb); // film_grain_characteristics_cancel_flag
353 
354  if (h->present) {
355  memset(h, 0, sizeof(*h));
356  h->model_id = get_bits(gb, 2);
357  h->separate_colour_description_present_flag = get_bits1(gb);
358  if (h->separate_colour_description_present_flag) {
359  h->bit_depth_luma = get_bits(gb, 3) + 8;
360  h->bit_depth_chroma = get_bits(gb, 3) + 8;
361  h->full_range = get_bits1(gb);
362  h->color_primaries = get_bits(gb, 8);
363  h->transfer_characteristics = get_bits(gb, 8);
364  h->matrix_coeffs = get_bits(gb, 8);
365  }
366  h->blending_mode_id = get_bits(gb, 2);
367  h->log2_scale_factor = get_bits(gb, 4);
368  for (int c = 0; c < 3; c++)
369  h->comp_model_present_flag[c] = get_bits1(gb);
370  for (int c = 0; c < 3; c++) {
371  if (h->comp_model_present_flag[c]) {
372  h->num_intensity_intervals[c] = get_bits(gb, 8) + 1;
373  h->num_model_values[c] = get_bits(gb, 3) + 1;
374  if (h->num_model_values[c] > 6)
375  return AVERROR_INVALIDDATA;
376  for (int i = 0; i < h->num_intensity_intervals[c]; i++) {
377  h->intensity_interval_lower_bound[c][i] = get_bits(gb, 8);
378  h->intensity_interval_upper_bound[c][i] = get_bits(gb, 8);
379  for (int j = 0; j < h->num_model_values[c]; j++)
380  h->comp_model_value[c][i][j] = get_se_golomb_long(gb);
381  }
382  }
383  }
384  if (IS_HEVC(codec_id))
385  h->persistence_flag = get_bits1(gb);
386  else
387  h->repetition_period = get_ue_golomb_long(gb);
388 
389  h->present = 1;
390  }
391 
392  return 0;
393 }
394 
395  int ff_h2645_sei_message_decode(H2645SEI *h, enum SEIType type,
396  enum AVCodecID codec_id, GetBitContext *gb,
397  GetByteContext *gbyte, void *logctx)
398 {
399  switch (type) {
400  case SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35:
401  return decode_registered_user_data(h, gbyte, codec_id, logctx);
402  case SEI_TYPE_USER_DATA_UNREGISTERED:
403  return decode_unregistered_user_data(&h->unregistered, gbyte, codec_id);
404  case SEI_TYPE_DISPLAY_ORIENTATION:
405  return decode_display_orientation(&h->display_orientation, gb);
406  case SEI_TYPE_FILM_GRAIN_CHARACTERISTICS:
407  return decode_film_grain_characteristics(&h->film_grain_characteristics, codec_id, gb);
408  case SEI_TYPE_FRAME_PACKING_ARRANGEMENT:
409  return decode_frame_packing_arrangement(&h->frame_packing, gb, codec_id);
410  case SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS:
411  return decode_alternative_transfer(&h->alternative_transfer, gbyte);
412  case SEI_TYPE_AMBIENT_VIEWING_ENVIRONMENT:
413  return decode_ambient_viewing_environment(&h->ambient_viewing_environment,
414  gbyte);
415  default:
416  return FF_H2645_SEI_MESSAGE_UNHANDLED;
417  }
418 }
419 
420  int ff_h2645_sei_ctx_replace(H2645SEI *dst, const H2645SEI *src)
421 {
422  int ret = av_buffer_replace(&dst->a53_caption.buf_ref,
423  src->a53_caption.buf_ref);
424  if (ret < 0)
425  return ret;
426 
427  for (unsigned i = 0; i < dst->unregistered.nb_buf_ref; i++)
428  av_buffer_unref(&dst->unregistered.buf_ref[i]);
429  dst->unregistered.nb_buf_ref = 0;
430 
431  if (src->unregistered.nb_buf_ref) {
432  ret = av_reallocp_array(&dst->unregistered.buf_ref,
433  src->unregistered.nb_buf_ref,
434  sizeof(*dst->unregistered.buf_ref));
435  if (ret < 0)
436  return ret;
437 
438  for (unsigned i = 0; i < src->unregistered.nb_buf_ref; i++) {
439  dst->unregistered.buf_ref[i] = av_buffer_ref(src->unregistered.buf_ref[i]);
440  if (!dst->unregistered.buf_ref[i])
441  return AVERROR(ENOMEM);
442  dst->unregistered.nb_buf_ref++;
443  }
444  }
445 
446  return 0;
447 }
448 
449  static int is_frame_packing_type_valid(SEIFpaType type, enum AVCodecID codec_id)
450 {
451  if (IS_H264(codec_id))
452  return type <= SEI_FPA_H264_TYPE_2D &&
453  type >= SEI_FPA_H264_TYPE_CHECKERBOARD;
454  else
455  return type <= SEI_FPA_TYPE_INTERLEAVE_TEMPORAL &&
456  type >= SEI_FPA_TYPE_SIDE_BY_SIDE;
457 }
458 
459  int ff_h2645_sei_to_frame(AVFrame *frame, H2645SEI *sei,
460  enum AVCodecID codec_id,
461  AVCodecContext *avctx, const H2645VUI *vui,
462  unsigned bit_depth_luma, unsigned bit_depth_chroma,
463  int seed)
464 {
465  H2645SEIFramePacking *fp = &sei->frame_packing;
466 
467  if (fp->present &&
468  is_frame_packing_type_valid(fp->arrangement_type, codec_id) &&
469  fp->content_interpretation_type > 0 &&
470  fp->content_interpretation_type < 3) {
471  AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
472 
473  if (!stereo)
474  return AVERROR(ENOMEM);
475 
476  switch (fp->arrangement_type) {
477 #if CONFIG_H264_SEI
478  case SEI_FPA_H264_TYPE_CHECKERBOARD:
479  stereo->type = AV_STEREO3D_CHECKERBOARD;
480  break;
481  case SEI_FPA_H264_TYPE_INTERLEAVE_COLUMN:
482  stereo->type = AV_STEREO3D_COLUMNS;
483  break;
484  case SEI_FPA_H264_TYPE_INTERLEAVE_ROW:
485  stereo->type = AV_STEREO3D_LINES;
486  break;
487 #endif
488  case SEI_FPA_TYPE_SIDE_BY_SIDE:
489  if (fp->quincunx_sampling_flag)
490  stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
491  else
492  stereo->type = AV_STEREO3D_SIDEBYSIDE;
493  break;
494  case SEI_FPA_TYPE_TOP_BOTTOM:
495  stereo->type = AV_STEREO3D_TOPBOTTOM;
496  break;
497  case SEI_FPA_TYPE_INTERLEAVE_TEMPORAL:
498  stereo->type = AV_STEREO3D_FRAMESEQUENCE;
499  break;
500 #if CONFIG_H264_SEI
501  case SEI_FPA_H264_TYPE_2D:
502  stereo->type = AV_STEREO3D_2D;
503  break;
504 #endif
505  }
506 
507  if (fp->content_interpretation_type == 2)
508  stereo->flags = AV_STEREO3D_FLAG_INVERT;
509 
510  if (fp->arrangement_type == SEI_FPA_TYPE_INTERLEAVE_TEMPORAL) {
511  if (fp->current_frame_is_frame0_flag)
512  stereo->view = AV_STEREO3D_VIEW_LEFT;
513  else
514  stereo->view = AV_STEREO3D_VIEW_RIGHT;
515  }
516  }
517 
518  if (sei->display_orientation.present &&
519  (sei->display_orientation.anticlockwise_rotation ||
520  sei->display_orientation.hflip ||
521  sei->display_orientation.vflip)) {
522  H2645SEIDisplayOrientation *o = &sei->display_orientation;
523  double angle = o->anticlockwise_rotation * 360 / (double) (1 << 16);
524  AVFrameSideData *rotation = av_frame_new_side_data(frame,
525  AV_FRAME_DATA_DISPLAYMATRIX,
526  sizeof(int32_t) * 9);
527  if (!rotation)
528  return AVERROR(ENOMEM);
529 
530  /* av_display_rotation_set() expects the angle in the clockwise
531  * direction, hence the first minus.
532  * The below code applies the flips after the rotation, yet
533  * the H.2645 specs require flipping to be applied first.
534  * Because of R O(phi) = O(-phi) R (where R is flipping around
535  * an arbitatry axis and O(phi) is the proper rotation by phi)
536  * we can create display matrices as desired by negating
537  * the degree once for every flip applied. */
538  angle = -angle * (1 - 2 * !!o->hflip) * (1 - 2 * !!o->vflip);
539  av_display_rotation_set((int32_t *)rotation->data, angle);
540  av_display_matrix_flip((int32_t *)rotation->data,
541  o->hflip, o->vflip);
542  }
543 
544  if (sei->a53_caption.buf_ref) {
545  H2645SEIA53Caption *a53 = &sei->a53_caption;
546  AVFrameSideData *sd = av_frame_new_side_data_from_buf(frame, AV_FRAME_DATA_A53_CC, a53->buf_ref);
547  if (!sd)
548  av_buffer_unref(&a53->buf_ref);
549  a53->buf_ref = NULL;
550  if (avctx)
551  avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
552  }
553 
554  for (unsigned i = 0; i < sei->unregistered.nb_buf_ref; i++) {
555  H2645SEIUnregistered *unreg = &sei->unregistered;
556 
557  if (unreg->buf_ref[i]) {
558  AVFrameSideData *sd = av_frame_new_side_data_from_buf(frame,
559  AV_FRAME_DATA_SEI_UNREGISTERED,
560  unreg->buf_ref[i]);
561  if (!sd)
562  av_buffer_unref(&unreg->buf_ref[i]);
563  unreg->buf_ref[i] = NULL;
564  }
565  }
566  sei->unregistered.nb_buf_ref = 0;
567 
568  if (sei->afd.present) {
569  AVFrameSideData *sd = av_frame_new_side_data(frame, AV_FRAME_DATA_AFD,
570  sizeof(uint8_t));
571 
572  if (sd) {
573  *sd->data = sei->afd.active_format_description;
574  sei->afd.present = 0;
575  }
576  }
577 
578  if (sei->film_grain_characteristics.present) {
579  H2645SEIFilmGrainCharacteristics *fgc = &sei->film_grain_characteristics;
580  AVFilmGrainParams *fgp = av_film_grain_params_create_side_data(frame);
581  AVFilmGrainH274Params *h274;
582 
583  if (!fgp)
584  return AVERROR(ENOMEM);
585 
586  fgp->type = AV_FILM_GRAIN_PARAMS_H274;
587  h274 = &fgp->codec.h274;
588 
589  fgp->seed = seed;
590 
591  h274->model_id = fgc->model_id;
592  if (fgc->separate_colour_description_present_flag) {
593  h274->bit_depth_luma = fgc->bit_depth_luma;
594  h274->bit_depth_chroma = fgc->bit_depth_chroma;
595  h274->color_range = fgc->full_range + 1;
596  h274->color_primaries = fgc->color_primaries;
597  h274->color_trc = fgc->transfer_characteristics;
598  h274->color_space = fgc->matrix_coeffs;
599  } else {
600  h274->bit_depth_luma = bit_depth_luma;
601  h274->bit_depth_chroma = bit_depth_chroma;
602  if (vui->video_signal_type_present_flag)
603  h274->color_range = vui->video_full_range_flag + 1;
604  else
605  h274->color_range = AVCOL_RANGE_UNSPECIFIED;
606  if (vui->colour_description_present_flag) {
607  h274->color_primaries = vui->colour_primaries;
608  h274->color_trc = vui->transfer_characteristics;
609  h274->color_space = vui->matrix_coeffs;
610  } else {
611  h274->color_primaries = AVCOL_PRI_UNSPECIFIED;
612  h274->color_trc = AVCOL_TRC_UNSPECIFIED;
613  h274->color_space = AVCOL_SPC_UNSPECIFIED;
614  }
615  }
616  h274->blending_mode_id = fgc->blending_mode_id;
617  h274->log2_scale_factor = fgc->log2_scale_factor;
618 
619  memcpy(&h274->component_model_present, &fgc->comp_model_present_flag,
620  sizeof(h274->component_model_present));
621  memcpy(&h274->num_intensity_intervals, &fgc->num_intensity_intervals,
622  sizeof(h274->num_intensity_intervals));
623  memcpy(&h274->num_model_values, &fgc->num_model_values,
624  sizeof(h274->num_model_values));
625  memcpy(&h274->intensity_interval_lower_bound, &fgc->intensity_interval_lower_bound,
626  sizeof(h274->intensity_interval_lower_bound));
627  memcpy(&h274->intensity_interval_upper_bound, &fgc->intensity_interval_upper_bound,
628  sizeof(h274->intensity_interval_upper_bound));
629  memcpy(&h274->comp_model_value, &fgc->comp_model_value,
630  sizeof(h274->comp_model_value));
631 
632  if (IS_H264(codec_id))
633  fgc->present = !!fgc->repetition_period;
634  else
635  fgc->present = fgc->persistence_flag;
636 
637  if (avctx)
638  avctx->properties |= FF_CODEC_PROPERTY_FILM_GRAIN;
639  }
640 
641  if (sei->ambient_viewing_environment.present) {
642  H2645SEIAmbientViewingEnvironment *env =
643  &sei->ambient_viewing_environment;
644 
645  AVAmbientViewingEnvironment *dst_env =
646  av_ambient_viewing_environment_create_side_data(frame);
647  if (!dst_env)
648  return AVERROR(ENOMEM);
649 
650  dst_env->ambient_illuminance = av_make_q(env->ambient_illuminance, 10000);
651  dst_env->ambient_light_x = av_make_q(env->ambient_light_x, 50000);
652  dst_env->ambient_light_y = av_make_q(env->ambient_light_y, 50000);
653  }
654 
655  return 0;
656 }
657 
658  void ff_h2645_sei_reset(H2645SEI *s)
659 {
660  av_buffer_unref(&s->a53_caption.buf_ref);
661 
662  for (unsigned i = 0; i < s->unregistered.nb_buf_ref; i++)
663  av_buffer_unref(&s->unregistered.buf_ref[i]);
664  s->unregistered.nb_buf_ref = 0;
665  av_freep(&s->unregistered.buf_ref);
666  av_buffer_unref(&s->dynamic_hdr_plus.info);
667  av_buffer_unref(&s->dynamic_hdr_vivid.info);
668 
669  s->ambient_viewing_environment.present = 0;
670 }
decode_film_grain_characteristics
static int decode_film_grain_characteristics(H2645SEIFilmGrainCharacteristics *h, enum AVCodecID codec_id, GetBitContext *gb)
Definition: h2645_sei.c:349
AV_STEREO3D_VIEW_LEFT
@ AV_STEREO3D_VIEW_LEFT
Frame contains only the left view.
Definition: stereo3d.h:153
H2645SEIFilmGrainCharacteristics::persistence_flag
int persistence_flag
Definition: h2645_sei.h:105
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
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
@ AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:114
SEI_FPA_H264_TYPE_CHECKERBOARD
@ SEI_FPA_H264_TYPE_CHECKERBOARD
Definition: sei.h:148
SEI_FPA_TYPE_INTERLEAVE_TEMPORAL
@ SEI_FPA_TYPE_INTERLEAVE_TEMPORAL
Definition: sei.h:153
H2645SEIAmbientViewingEnvironment::ambient_light_x
uint16_t ambient_light_x
Definition: h2645_sei.h:82
H2645SEIFramePacking
Definition: h2645_sei.h:57
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:670
GetByteContext
Definition: bytestream.h:33
H2645SEIAFD
Definition: h2645_sei.h:38
AVAmbientViewingEnvironment
Ambient viewing environment metadata as defined by H.274.
Definition: ambient_viewing_environment.h:36
AVFilmGrainH274Params::color_space
enum AVColorSpace color_space
Definition: film_grain_params.h:152
get_se_golomb_long
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
H2645SEIFilmGrainCharacteristics::bit_depth_chroma
int bit_depth_chroma
Definition: h2645_sei.h:91
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
ff_h2645_sei_to_frame
int ff_h2645_sei_to_frame(AVFrame *frame, H2645SEI *sei, enum AVCodecID codec_id, AVCodecContext *avctx, const H2645VUI *vui, unsigned bit_depth_luma, unsigned bit_depth_chroma, int seed)
Definition: h2645_sei.c:459
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
H2645VUI::matrix_coeffs
enum AVColorSpace matrix_coeffs
Definition: h2645_vui.h:39
AVFilmGrainH274Params::blending_mode_id
int blending_mode_id
Specifies the blending mode used to blend the simulated film grain with the decoded images.
Definition: film_grain_params.h:160
H2645SEIA53Caption::buf_ref
AVBufferRef * buf_ref
Definition: h2645_sei.h:35
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
IS_H264
#define IS_H264(codec_id)
Definition: h2645_sei.c:42
H2645SEIA53Caption
Definition: h2645_sei.h:34
av_display_matrix_flip
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition: display.c:66
AVAmbientViewingEnvironment::ambient_light_x
AVRational ambient_light_x
Normalized x chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
Definition: ambient_viewing_environment.h:47
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:561
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVFilmGrainH274Params::color_range
enum AVColorRange color_range
Definition: film_grain_params.h:149
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...
Definition: display.c:51
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:85
SEI_FPA_TYPE_TOP_BOTTOM
@ SEI_FPA_TYPE_TOP_BOTTOM
Definition: sei.h:152
H2645VUI::colour_primaries
enum AVColorPrimaries colour_primaries
Definition: h2645_vui.h:37
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AV_STEREO3D_VIEW_RIGHT
@ AV_STEREO3D_VIEW_RIGHT
Frame contains only the right view.
Definition: stereo3d.h:158
H2645VUI::video_full_range_flag
int video_full_range_flag
Definition: h2645_vui.h:35
AVFilmGrainParams::seed
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
Definition: film_grain_params.h:228
H2645SEIDisplayOrientation
Definition: h2645_sei.h:68
H2645VUI::video_signal_type_present_flag
int video_signal_type_present_flag
Definition: h2645_vui.h:33
ff_h2645_sei_message_decode
int ff_h2645_sei_message_decode(H2645SEI *h, enum SEIType type, enum AVCodecID codec_id, GetBitContext *gb, GetByteContext *gbyte, void *logctx)
Decode a single SEI message.
Definition: h2645_sei.c:395
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:371
golomb.h
exp golomb vlc stuff
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:64
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:325
SEI_FPA_H264_TYPE_INTERLEAVE_COLUMN
@ SEI_FPA_H264_TYPE_INTERLEAVE_COLUMN
Definition: sei.h:149
H2645SEI::a53_caption
H2645SEIA53Caption a53_caption
Definition: h2645_sei.h:109
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:52
H2645SEIFilmGrainCharacteristics::intensity_interval_upper_bound
uint8_t intensity_interval_upper_bound[3][256]
Definition: h2645_sei.h:102
GetBitContext
Definition: get_bits.h:107
av_dynamic_hdr_vivid_alloc
AVDynamicHDRVivid * av_dynamic_hdr_vivid_alloc(size_t *size)
Copyright (c) 2021 Limin Wang <lance.lmwang at gmail.com>
Definition: hdr_dynamic_vivid_metadata.c:24
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
SEI_TYPE_AMBIENT_VIEWING_ENVIRONMENT
@ SEI_TYPE_AMBIENT_VIEWING_ENVIRONMENT
Definition: sei.h:107
AVAmbientViewingEnvironment::ambient_illuminance
AVRational ambient_illuminance
Environmental illuminance of the ambient viewing environment in lux.
Definition: ambient_viewing_environment.h:40
AVFilmGrainH274Params::intensity_interval_upper_bound
uint8_t intensity_interval_upper_bound[3][256]
Specifies the upper bound of each intensity interval for which the set of model values applies for th...
Definition: film_grain_params.h:194
AVFilmGrainH274Params::bit_depth_luma
int bit_depth_luma
Specifies the bit depth used for the luma component.
Definition: film_grain_params.h:142
is_frame_packing_type_valid
static int is_frame_packing_type_valid(SEIFpaType type, enum AVCodecID codec_id)
Definition: h2645_sei.c:449
AV_STEREO3D_FRAMESEQUENCE
@ AV_STEREO3D_FRAMESEQUENCE
Views are alternated temporally.
Definition: stereo3d.h:89
film_grain_params.h
H2645SEIFilmGrainCharacteristics::intensity_interval_lower_bound
uint8_t intensity_interval_lower_bound[3][256]
Definition: h2645_sei.h:101
H2645SEIFilmGrainCharacteristics::matrix_coeffs
int matrix_coeffs
Definition: h2645_sei.h:95
H2645SEIDisplayOrientation::anticlockwise_rotation
int anticlockwise_rotation
Definition: h2645_sei.h:70
AV_STEREO3D_LINES
@ AV_STEREO3D_LINES
Views are packed per line, as if interlaced.
Definition: stereo3d.h:126
stereo3d.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
SEI_TYPE_FRAME_PACKING_ARRANGEMENT
@ SEI_TYPE_FRAME_PACKING_ARRANGEMENT
Definition: sei.h:75
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:215
SEI_FPA_H264_TYPE_INTERLEAVE_ROW
@ SEI_FPA_H264_TYPE_INTERLEAVE_ROW
Definition: sei.h:150
decode_registered_user_data_closed_caption
static int decode_registered_user_data_closed_caption(H2645SEIA53Caption *h, GetByteContext *gb)
Definition: h2645_sei.c:118
av_film_grain_params_create_side_data
AVFilmGrainParams * av_film_grain_params_create_side_data(AVFrame *frame)
Allocate a complete AVFilmGrainParams and add it to the frame.
Definition: film_grain_params.c:31
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
H2645SEIAmbientViewingEnvironment
Definition: h2645_sei.h:79
H2645SEIFilmGrainCharacteristics::log2_scale_factor
int log2_scale_factor
Definition: h2645_sei.h:97
SEIType
SEIType
Definition: sei.h:29
SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
Definition: sei.h:34
get_bits.h
decode_unregistered_user_data
static int decode_unregistered_user_data(H2645SEIUnregistered *h, GetByteContext *gb, enum AVCodecID codec_id)
Definition: h2645_sei.c:222
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:388
AVFilmGrainH274Params::comp_model_value
int16_t comp_model_value[3][256][6]
Specifies the model values for the component for each intensity interval.
Definition: film_grain_params.h:205
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:536
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1854
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:182
H2645SEIDisplayOrientation::hflip
int hflip
Definition: h2645_sei.h:71
AVFilmGrainH274Params::model_id
int model_id
Specifies the film grain simulation mode.
Definition: film_grain_params.h:137
ff_parse_a53_cc
int ff_parse_a53_cc(AVBufferRef **pbuf, const uint8_t *data, int size)
Parse a data array for ATSC A53 Part 4 Closed Captions and store them in an AVBufferRef.
Definition: atsc_a53.c:68
decode_registered_user_data
static int decode_registered_user_data(H2645SEI *h, GetByteContext *gb, enum AVCodecID codec_id, void *logctx)
Definition: h2645_sei.c:125
NULL
#define NULL
Definition: coverity.c:32
H2645SEIFilmGrainCharacteristics::color_primaries
int color_primaries
Definition: h2645_sei.h:93
H2645VUI::colour_description_present_flag
int colour_description_present_flag
Definition: h2645_vui.h:36
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
decode_frame_packing_arrangement
static int decode_frame_packing_arrangement(H2645SEIFramePacking *h, GetBitContext *gb, enum AVCodecID codec_id)
Definition: h2645_sei.c:278
H2645SEIFilmGrainCharacteristics::repetition_period
int repetition_period
Definition: h2645_sei.h:104
H2645SEIFilmGrainCharacteristics::model_id
int model_id
Definition: h2645_sei.h:88
FF_H2645_SEI_MESSAGE_UNHANDLED
@ FF_H2645_SEI_MESSAGE_UNHANDLED
Definition: h2645_sei.h:123
H2645SEIFilmGrainCharacteristics::comp_model_present_flag
int comp_model_present_flag[3]
Definition: h2645_sei.h:98
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:378
H2645SEI
Definition: h2645_sei.h:108
AVDynamicHDRVivid
This struct represents dynamic metadata for color volume transform - CUVA 005.1:2021 standard.
Definition: hdr_dynamic_vivid_metadata.h:249
H2645VUI
Definition: h2645_vui.h:27
dynamic_hdr10_plus.h
double
double
Definition: af_crystalizer.c:132
av_frame_new_side_data_from_buf
AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)
Add a new side data to a frame from an existing AVBufferRef.
Definition: frame.c:638
H2645SEIFilmGrainCharacteristics::num_intensity_intervals
uint16_t num_intensity_intervals[3]
Definition: h2645_sei.h:99
fp
#define fp
Definition: regdef.h:44
seed
static unsigned int seed
Definition: videogen.c:78
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:90
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:825
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:627
IS_HEVC
#define IS_HEVC(codec_id)
Definition: h2645_sei.c:43
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_FRAME_DATA_SEI_UNREGISTERED
@ AV_FRAME_DATA_SEI_UNREGISTERED
User data unregistered metadata associated with a video frame.
Definition: frame.h:178
decode_alternative_transfer
static int decode_alternative_transfer(H2645SEIAlternativeTransfer *s, GetByteContext *gb)
Definition: h2645_sei.c:312
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
H2645SEIFilmGrainCharacteristics::bit_depth_luma
int bit_depth_luma
Definition: h2645_sei.h:90
H2645SEIFilmGrainCharacteristics::num_model_values
uint8_t num_model_values[3]
Definition: h2645_sei.h:100
AV_STEREO3D_CHECKERBOARD
@ AV_STEREO3D_CHECKERBOARD
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:101
H2645SEIDisplayOrientation::vflip
int vflip
Definition: h2645_sei.h:71
H2645VUI::transfer_characteristics
enum AVColorTransferCharacteristic transfer_characteristics
Definition: h2645_vui.h:38
AVFilmGrainH274Params::component_model_present
int component_model_present[3]
Indicates if the modelling of film grain for a given component is present.
Definition: film_grain_params.h:170
h2645_sei.h
size
int size
Definition: twinvq_data.h:10344
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AVFrameSideData::data
uint8_t * data
Definition: frame.h:238
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:216
user_data
static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)
Definition: cbs_mpeg2_syntax_template.c:59
H2645SEIFilmGrainCharacteristics::blending_mode_id
int blending_mode_id
Definition: h2645_sei.h:96
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
Definition: mem.c:223
SEI_FPA_TYPE_SIDE_BY_SIDE
@ SEI_FPA_TYPE_SIDE_BY_SIDE
Definition: sei.h:151
ff_h2645_sei_reset
void ff_h2645_sei_reset(H2645SEI *s)
Definition: h2645_sei.c:658
SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS
@ SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS
Definition: sei.h:106
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:403
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
AVFilmGrainParams::h274
AVFilmGrainH274Params h274
Definition: film_grain_params.h:237
decode_registered_user_data_afd
static int decode_registered_user_data_afd(H2645SEIAFD *h, GetByteContext *gb)
Definition: h2645_sei.c:99
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:164
ff_parse_itu_t_t35_to_dynamic_hdr_vivid
int ff_parse_itu_t_t35_to_dynamic_hdr_vivid(AVDynamicHDRVivid *s, const uint8_t *data, int size)
Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRVivid).
Definition: dynamic_hdr_vivid.c:32
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
flag
#define flag(name)
Definition: cbs_av1.c:553
SEI_FPA_H264_TYPE_2D
@ SEI_FPA_H264_TYPE_2D
Definition: sei.h:154
H2645SEIFilmGrainCharacteristics::transfer_characteristics
int transfer_characteristics
Definition: h2645_sei.h:94
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1851
HEVCSEIDynamicHDRPlus
Definition: h2645_sei.h:43
av_ambient_viewing_environment_create_side_data
AVAmbientViewingEnvironment * av_ambient_viewing_environment_create_side_data(AVFrame *frame)
Allocate and add an AVAmbientViewingEnvironment structure to an existing AVFrame as side data.
Definition: ambient_viewing_environment.c:37
AVFilmGrainH274Params
This structure describes how to handle film grain synthesis for codecs using the ITU-T H....
Definition: film_grain_params.h:132
AVFilmGrainH274Params::num_intensity_intervals
uint16_t num_intensity_intervals[3]
Specifies the number of intensity intervals for which a specific set of model values has been estimat...
Definition: film_grain_params.h:176
display.h
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:76
SEI_TYPE_DISPLAY_ORIENTATION
@ SEI_TYPE_DISPLAY_ORIENTATION
Definition: sei.h:77
H2645SEIFilmGrainCharacteristics::present
int present
Definition: h2645_sei.h:87
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:590
AVFilmGrainH274Params::color_primaries
enum AVColorPrimaries color_primaries
Definition: film_grain_params.h:150
ambient_viewing_environment.h
AVFilmGrainH274Params::intensity_interval_lower_bound
uint8_t intensity_interval_lower_bound[3][256]
Specifies the lower ounds of each intensity interval for whichthe set of model values applies for the...
Definition: film_grain_params.h:188
H2645SEIFilmGrainCharacteristics::separate_colour_description_present_flag
int separate_colour_description_present_flag
Definition: h2645_sei.h:89
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
H2645SEIUnregistered
Definition: h2645_sei.h:51
AV_STEREO3D_COLUMNS
@ AV_STEREO3D_COLUMNS
Views are packed per column.
Definition: stereo3d.h:138
atsc_a53.h
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:177
SEIFpaType
SEIFpaType
frame_packing_arrangement types.
Definition: sei.h:147
H2645SEI::unregistered
H2645SEIUnregistered unregistered
Definition: h2645_sei.h:113
AVCodecContext
main external API structure.
Definition: avcodec.h:426
AV_FILM_GRAIN_PARAMS_H274
@ AV_FILM_GRAIN_PARAMS_H274
The union is valid when interpreted as AVFilmGrainH274Params (codec.h274)
Definition: film_grain_params.h:35
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
decode_ambient_viewing_environment
static int decode_ambient_viewing_environment(H2645SEIAmbientViewingEnvironment *s, GetByteContext *gb)
Definition: h2645_sei.c:324
AVFilmGrainH274Params::log2_scale_factor
int log2_scale_factor
Specifies a scale factor used in the film grain characterization equations.
Definition: film_grain_params.h:165
ff_parse_itu_t_t35_to_dynamic_hdr10_plus
int ff_parse_itu_t_t35_to_dynamic_hdr10_plus(AVDynamicHDRPlus *s, const uint8_t *data, int size)
Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus).
Definition: dynamic_hdr10_plus.c:30
HEVCSEIDynamicHDRVivid
Definition: h2645_sei.h:47
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:1853
H2645SEIAmbientViewingEnvironment::ambient_illuminance
uint32_t ambient_illuminance
Definition: h2645_sei.h:81
AVFilmGrainH274Params::num_model_values
uint8_t num_model_values[3]
Specifies the number of model values present for each intensity interval in which the film grain has ...
Definition: film_grain_params.h:182
H2645SEIAmbientViewingEnvironment::ambient_light_y
uint16_t ambient_light_y
Definition: h2645_sei.h:83
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:277
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
ff_h2645_sei_ctx_replace
int ff_h2645_sei_ctx_replace(H2645SEI *dst, const H2645SEI *src)
Definition: h2645_sei.c:420
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:34
AVFilmGrainH274Params::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: film_grain_params.h:151
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:236
av_dynamic_hdr_plus_alloc
AVDynamicHDRPlus * av_dynamic_hdr_plus_alloc(size_t *size)
Copyright (c) 2018 Mohammad Izadi <moh.izadi at gmail.com>
Definition: hdr_dynamic_metadata.c:24
dynamic_hdr_vivid.h
AVStereo3D::view
enum AVStereo3DView view
Determines which views are packed.
Definition: stereo3d.h:187
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
H2645SEIFilmGrainCharacteristics::full_range
int full_range
Definition: h2645_sei.h:92
H2645SEIUnregistered::nb_buf_ref
unsigned nb_buf_ref
Definition: h2645_sei.h:53
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVFilmGrainH274Params::bit_depth_chroma
int bit_depth_chroma
Specifies the bit depth used for the chroma components.
Definition: film_grain_params.h:147
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:173
AVAmbientViewingEnvironment::ambient_light_y
AVRational ambient_light_y
Normalized y chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
Definition: ambient_viewing_environment.h:54
H2645SEIFilmGrainCharacteristics::comp_model_value
int16_t comp_model_value[3][256][6]
Definition: h2645_sei.h:103
H2645SEIUnregistered::buf_ref
AVBufferRef ** buf_ref
Definition: h2645_sei.h:52
AVFilmGrainParams::codec
union AVFilmGrainParams::@319 codec
Additional fields may be added both here and in any structure included.
SEI_TYPE_FILM_GRAIN_CHARACTERISTICS
@ SEI_TYPE_FILM_GRAIN_CHARACTERISTICS
Definition: sei.h:49
AVFilmGrainParams::type
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
Definition: film_grain_params.h:220
H2645SEIAlternativeTransfer
Definition: h2645_sei.h:74
decode_display_orientation
static int decode_display_orientation(H2645SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h2645_sei.c:260
H2645SEIFilmGrainCharacteristics
Definition: h2645_sei.h:86
Generated on Tue Feb 28 2023 21:33:17 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /