FFmpeg
h264_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/avstring.h"
20 #include "libavutil/display.h"
21 #include "libavutil/common.h"
22 #include "libavutil/opt.h"
23 
24 #include "bsf.h"
25 #include "cbs.h"
26 #include "cbs_h264.h"
27 #include "h264.h"
28 #include "h264_levels.h"
29 #include "h264_sei.h"
30 
31 enum {
36 };
37 
38 enum {
41 };
42 
43 enum {
45  LEVEL_AUTO = -1,
46 };
47 
48 typedef struct H264MetadataContext {
49  const AVClass *class;
50 
53 
55 
56  int aud;
57 
59 
65 
67 
70 
71  int crop_left;
73  int crop_top;
75 
76  const char *sei_user_data;
77 
79 
81  double rotate;
82  int flip;
83 
84  int level;
86 
87 
89  H264RawSPS *sps)
90 {
92  int need_vui = 0;
93  int crop_unit_x, crop_unit_y;
94 
95  if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
96  // Table E-1.
97  static const AVRational sar_idc[] = {
98  { 0, 0 }, // Unspecified (never written here).
99  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
100  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
101  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
102  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
103  };
104  int num, den, i;
105 
106  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
107  ctx->sample_aspect_ratio.den, 65535);
108 
109  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
110  if (num == sar_idc[i].num &&
111  den == sar_idc[i].den)
112  break;
113  }
114  if (i == FF_ARRAY_ELEMS(sar_idc)) {
115  sps->vui.aspect_ratio_idc = 255;
116  sps->vui.sar_width = num;
117  sps->vui.sar_height = den;
118  } else {
119  sps->vui.aspect_ratio_idc = i;
120  }
121  sps->vui.aspect_ratio_info_present_flag = 1;
122  need_vui = 1;
123  }
124 
125 #define SET_OR_INFER(field, value, present_flag, infer) do { \
126  if (value >= 0) { \
127  field = value; \
128  need_vui = 1; \
129  } else if (!present_flag) \
130  field = infer; \
131  } while (0)
132 
133  if (ctx->video_format >= 0 ||
134  ctx->video_full_range_flag >= 0 ||
135  ctx->colour_primaries >= 0 ||
136  ctx->transfer_characteristics >= 0 ||
137  ctx->matrix_coefficients >= 0) {
138 
139  SET_OR_INFER(sps->vui.video_format, ctx->video_format,
140  sps->vui.video_signal_type_present_flag, 5);
141 
142  SET_OR_INFER(sps->vui.video_full_range_flag,
143  ctx->video_full_range_flag,
144  sps->vui.video_signal_type_present_flag, 0);
145 
146  if (ctx->colour_primaries >= 0 ||
147  ctx->transfer_characteristics >= 0 ||
148  ctx->matrix_coefficients >= 0) {
149 
150  SET_OR_INFER(sps->vui.colour_primaries,
151  ctx->colour_primaries,
152  sps->vui.colour_description_present_flag, 2);
153 
154  SET_OR_INFER(sps->vui.transfer_characteristics,
155  ctx->transfer_characteristics,
156  sps->vui.colour_description_present_flag, 2);
157 
158  SET_OR_INFER(sps->vui.matrix_coefficients,
159  ctx->matrix_coefficients,
160  sps->vui.colour_description_present_flag, 2);
161 
162  sps->vui.colour_description_present_flag = 1;
163  }
164  sps->vui.video_signal_type_present_flag = 1;
165  need_vui = 1;
166  }
167 
168  if (ctx->chroma_sample_loc_type >= 0) {
169  sps->vui.chroma_sample_loc_type_top_field =
170  ctx->chroma_sample_loc_type;
171  sps->vui.chroma_sample_loc_type_bottom_field =
172  ctx->chroma_sample_loc_type;
173  sps->vui.chroma_loc_info_present_flag = 1;
174  need_vui = 1;
175  }
176 
177  if (ctx->tick_rate.num && ctx->tick_rate.den) {
178  int num, den;
179 
180  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
181  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
182 
183  sps->vui.time_scale = num;
184  sps->vui.num_units_in_tick = den;
185 
186  sps->vui.timing_info_present_flag = 1;
187  need_vui = 1;
188  }
189  SET_OR_INFER(sps->vui.fixed_frame_rate_flag,
190  ctx->fixed_frame_rate_flag,
191  sps->vui.timing_info_present_flag, 0);
192 
193  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
194  crop_unit_x = 1;
195  crop_unit_y = 2 - sps->frame_mbs_only_flag;
196  } else {
197  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
198  crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *
199  (2 - sps->frame_mbs_only_flag);
200  }
201 #define CROP(border, unit) do { \
202  if (ctx->crop_ ## border >= 0) { \
203  if (ctx->crop_ ## border % unit != 0) { \
204  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
205  "must be a multiple of %d.\n", #border, unit); \
206  return AVERROR(EINVAL); \
207  } \
208  sps->frame_crop_ ## border ## _offset = \
209  ctx->crop_ ## border / unit; \
210  sps->frame_cropping_flag = 1; \
211  } \
212  } while (0)
213  CROP(left, crop_unit_x);
214  CROP(right, crop_unit_x);
215  CROP(top, crop_unit_y);
216  CROP(bottom, crop_unit_y);
217 #undef CROP
218 
219  if (ctx->level != LEVEL_UNSET) {
220  int level_idc;
221 
222  if (ctx->level == LEVEL_AUTO) {
223  const H264LevelDescriptor *desc;
224  int64_t bit_rate;
225  int width, height, dpb_frames;
226  int framerate;
227 
228  if (sps->vui.nal_hrd_parameters_present_flag) {
229  bit_rate = (sps->vui.nal_hrd_parameters.bit_rate_value_minus1[0] + 1) *
230  (INT64_C(1) << (sps->vui.nal_hrd_parameters.bit_rate_scale + 6));
231  } else if (sps->vui.vcl_hrd_parameters_present_flag) {
232  bit_rate = (sps->vui.vcl_hrd_parameters.bit_rate_value_minus1[0] + 1) *
233  (INT64_C(1) << (sps->vui.vcl_hrd_parameters.bit_rate_scale + 6));
234  // Adjust for VCL vs. NAL limits.
235  bit_rate = bit_rate * 6 / 5;
236  } else {
237  bit_rate = 0;
238  }
239 
240  // Don't use max_dec_frame_buffering if it is only inferred.
241  dpb_frames = sps->vui.bitstream_restriction_flag ?
242  sps->vui.max_dec_frame_buffering : H264_MAX_DPB_FRAMES;
243 
244  width = 16 * (sps->pic_width_in_mbs_minus1 + 1);
245  height = 16 * (sps->pic_height_in_map_units_minus1 + 1) *
246  (2 - sps->frame_mbs_only_flag);
247 
248  if (sps->vui.timing_info_present_flag)
249  framerate = sps->vui.time_scale / sps->vui.num_units_in_tick / 2;
250  else
251  framerate = 0;
252 
253  desc = ff_h264_guess_level(sps->profile_idc, bit_rate, framerate,
255  if (desc) {
256  level_idc = desc->level_idc;
257  } else {
258  av_log(bsf, AV_LOG_WARNING, "Stream does not appear to "
259  "conform to any level: using level 6.2.\n");
260  level_idc = 62;
261  }
262  } else {
263  level_idc = ctx->level;
264  }
265 
266  if (level_idc == 9) {
267  if (sps->profile_idc == 66 ||
268  sps->profile_idc == 77 ||
269  sps->profile_idc == 88) {
270  sps->level_idc = 11;
271  sps->constraint_set3_flag = 1;
272  } else {
273  sps->level_idc = 9;
274  }
275  } else {
276  sps->level_idc = level_idc;
277  }
278  }
279 
280  if (need_vui)
281  sps->vui_parameters_present_flag = 1;
282 
283  return 0;
284 }
285 
287 {
289  CodedBitstreamFragment *au = &ctx->access_unit;
290  int err, i, j, has_sps;
291  H264RawAUD aud;
292 
293  err = ff_bsf_get_packet_ref(bsf, pkt);
294  if (err < 0)
295  return err;
296 
297  err = ff_cbs_read_packet(ctx->cbc, au, pkt);
298  if (err < 0) {
299  av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
300  goto fail;
301  }
302 
303  if (au->nb_units == 0) {
304  av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
305  err = AVERROR_INVALIDDATA;
306  goto fail;
307  }
308 
309  // If an AUD is present, it must be the first NAL unit.
310  if (au->units[0].type == H264_NAL_AUD) {
311  if (ctx->aud == REMOVE)
312  ff_cbs_delete_unit(ctx->cbc, au, 0);
313  } else {
314  if (ctx->aud == INSERT) {
315  static const int primary_pic_type_table[] = {
316  0x084, // 2, 7
317  0x0a5, // 0, 2, 5, 7
318  0x0e7, // 0, 1, 2, 5, 6, 7
319  0x210, // 4, 9
320  0x318, // 3, 4, 8, 9
321  0x294, // 2, 4, 7, 9
322  0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
323  0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
324  };
325  int primary_pic_type_mask = 0xff;
326 
327  for (i = 0; i < au->nb_units; i++) {
328  if (au->units[i].type == H264_NAL_SLICE ||
329  au->units[i].type == H264_NAL_IDR_SLICE) {
330  H264RawSlice *slice = au->units[i].content;
331  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
332  if (!(primary_pic_type_table[j] &
333  (1 << slice->header.slice_type)))
334  primary_pic_type_mask &= ~(1 << j);
335  }
336  }
337  }
338  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
339  if (primary_pic_type_mask & (1 << j))
340  break;
341  if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
342  av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
343  "invalid slice types?\n");
344  err = AVERROR_INVALIDDATA;
345  goto fail;
346  }
347 
348  aud = (H264RawAUD) {
349  .nal_unit_header.nal_unit_type = H264_NAL_AUD,
350  .primary_pic_type = j,
351  };
352 
353  err = ff_cbs_insert_unit_content(ctx->cbc, au,
354  0, H264_NAL_AUD, &aud, NULL);
355  if (err < 0) {
356  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
357  goto fail;
358  }
359  }
360  }
361 
362  has_sps = 0;
363  for (i = 0; i < au->nb_units; i++) {
364  if (au->units[i].type == H264_NAL_SPS) {
365  err = h264_metadata_update_sps(bsf, au->units[i].content);
366  if (err < 0)
367  goto fail;
368  has_sps = 1;
369  }
370  }
371 
372  // Only insert the SEI in access units containing SPSs, and also
373  // unconditionally in the first access unit we ever see.
374  if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
375  H264RawSEIPayload payload = {
377  };
380 
381  for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
382  int c, v;
383  c = ctx->sei_user_data[i];
384  if (c == '-') {
385  continue;
386  } else if (av_isxdigit(c)) {
387  c = av_tolower(c);
388  v = (c <= '9' ? c - '0' : c - 'a' + 10);
389  } else {
390  goto invalid_user_data;
391  }
392  if (i & 1)
393  udu->uuid_iso_iec_11578[j / 2] |= v;
394  else
395  udu->uuid_iso_iec_11578[j / 2] = v << 4;
396  ++j;
397  }
398  if (j == 32 && ctx->sei_user_data[i] == '+') {
399  size_t len = strlen(ctx->sei_user_data + i + 1);
400 
401  udu->data_ref = av_buffer_alloc(len + 1);
402  if (!udu->data_ref) {
403  err = AVERROR(ENOMEM);
404  goto fail;
405  }
406 
407  udu->data = udu->data_ref->data;
408  udu->data_length = len + 1;
409  memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
410 
411  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
412  if (err < 0) {
413  av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
414  "message to access unit.\n");
415  goto fail;
416  }
417 
418  } else {
419  invalid_user_data:
420  av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
421  "must be \"UUID+string\".\n");
422  err = AVERROR(EINVAL);
423  goto fail;
424  }
425  }
426 
427  if (ctx->delete_filler) {
428  for (i = au->nb_units - 1; i >= 0; i--) {
429  if (au->units[i].type == H264_NAL_FILLER_DATA) {
430  ff_cbs_delete_unit(ctx->cbc, au, i);
431  continue;
432  }
433 
434  if (au->units[i].type == H264_NAL_SEI) {
435  // Filler SEI messages.
436  H264RawSEI *sei = au->units[i].content;
437 
438  for (j = sei->payload_count - 1; j >= 0; j--) {
439  if (sei->payload[j].payload_type ==
442  &au->units[i], j);
443  }
444  }
445  }
446  }
447 
448  if (ctx->display_orientation != PASS) {
449  for (i = au->nb_units - 1; i >= 0; i--) {
450  H264RawSEI *sei;
451  if (au->units[i].type != H264_NAL_SEI)
452  continue;
453  sei = au->units[i].content;
454 
455  for (j = sei->payload_count - 1; j >= 0; j--) {
457  int32_t *matrix;
458 
459  if (sei->payload[j].payload_type !=
461  continue;
462  disp = &sei->payload[j].payload.display_orientation;
463 
464  if (ctx->display_orientation == REMOVE ||
465  ctx->display_orientation == INSERT) {
467  &au->units[i], j);
468  continue;
469  }
470 
471  matrix = av_malloc(9 * sizeof(int32_t));
472  if (!matrix) {
473  err = AVERROR(ENOMEM);
474  goto fail;
475  }
476 
478  disp->anticlockwise_rotation *
479  180.0 / 65536.0);
480  av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
481 
482  // If there are multiple display orientation messages in an
483  // access unit, then the last one added to the packet (i.e.
484  // the first one in the access unit) will prevail.
486  (uint8_t*)matrix,
487  9 * sizeof(int32_t));
488  if (err < 0) {
489  av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
490  "displaymatrix side data to packet.\n");
491  av_free(matrix);
492  goto fail;
493  }
494  }
495  }
496  }
497  if (ctx->display_orientation == INSERT) {
498  H264RawSEIPayload payload = {
500  };
502  &payload.payload.display_orientation;
503  uint8_t *data;
504  int size;
505  int write = 0;
506 
508  if (data && size >= 9 * sizeof(int32_t)) {
509  int32_t matrix[9];
510  int hflip, vflip;
511  double angle;
512 
513  memcpy(matrix, data, sizeof(matrix));
514 
515  hflip = vflip = 0;
516  if (matrix[0] < 0 && matrix[4] > 0)
517  hflip = 1;
518  else if (matrix[0] > 0 && matrix[4] < 0)
519  vflip = 1;
520  av_display_matrix_flip(matrix, hflip, vflip);
521 
522  angle = av_display_rotation_get(matrix);
523 
524  if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
525  matrix[2] != 0 || matrix[5] != 0 ||
526  matrix[6] != 0 || matrix[7] != 0) {
527  av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
528  "representable in H.264 parameters.\n");
529  } else {
530  disp->hor_flip = hflip;
531  disp->ver_flip = vflip;
532  disp->anticlockwise_rotation =
533  (uint16_t)rint((angle >= 0.0 ? angle
534  : angle + 360.0) *
535  65536.0 / 360.0);
536  write = 1;
537  }
538  }
539 
540  if (has_sps || !ctx->done_first_au) {
541  if (!isnan(ctx->rotate)) {
542  disp->anticlockwise_rotation =
543  (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
544  : ctx->rotate + 360.0) *
545  65536.0 / 360.0);
546  write = 1;
547  }
548  if (ctx->flip) {
549  disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
550  disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
551  write = 1;
552  }
553  }
554 
555  if (write) {
557 
558  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
559  if (err < 0) {
560  av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
561  "SEI message to access unit.\n");
562  goto fail;
563  }
564  }
565  }
566 
567  err = ff_cbs_write_packet(ctx->cbc, pkt, au);
568  if (err < 0) {
569  av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
570  goto fail;
571  }
572 
573  ctx->done_first_au = 1;
574 
575  err = 0;
576 fail:
577  ff_cbs_fragment_reset(ctx->cbc, au);
578 
579  if (err < 0)
581 
582  return err;
583 }
584 
586 {
588  CodedBitstreamFragment *au = &ctx->access_unit;
589  int err, i;
590 
591  err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
592  if (err < 0)
593  return err;
594 
595  if (bsf->par_in->extradata) {
596  err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
597  if (err < 0) {
598  av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
599  goto fail;
600  }
601 
602  for (i = 0; i < au->nb_units; i++) {
603  if (au->units[i].type == H264_NAL_SPS) {
604  err = h264_metadata_update_sps(bsf, au->units[i].content);
605  if (err < 0)
606  goto fail;
607  }
608  }
609 
610  err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
611  if (err < 0) {
612  av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
613  goto fail;
614  }
615  }
616 
617  err = 0;
618 fail:
619  ff_cbs_fragment_reset(ctx->cbc, au);
620  return err;
621 }
622 
624 {
626 
627  ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
628  ff_cbs_close(&ctx->cbc);
629 }
630 
631 #define OFFSET(x) offsetof(H264MetadataContext, x)
632 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
633 static const AVOption h264_metadata_options[] = {
634  { "aud", "Access Unit Delimiter NAL units",
636  { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
637  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
638  { .i64 = PASS }, .flags = FLAGS, .unit = "aud" },
639  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
640  { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
641  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
642  { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
643 
644  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
645  OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
646  { .dbl = 0.0 }, 0, 65535, FLAGS },
647 
648  { "video_format", "Set video format (table E-2)",
649  OFFSET(video_format), AV_OPT_TYPE_INT,
650  { .i64 = -1 }, -1, 7, FLAGS},
651  { "video_full_range_flag", "Set video full range flag",
652  OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
653  { .i64 = -1 }, -1, 1, FLAGS },
654  { "colour_primaries", "Set colour primaries (table E-3)",
655  OFFSET(colour_primaries), AV_OPT_TYPE_INT,
656  { .i64 = -1 }, -1, 255, FLAGS },
657  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
659  { .i64 = -1 }, -1, 255, FLAGS },
660  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
661  OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
662  { .i64 = -1 }, -1, 255, FLAGS },
663 
664  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
665  OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
666  { .i64 = -1 }, -1, 6, FLAGS },
667 
668  { "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
669  OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
670  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
671  { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
672  OFFSET(fixed_frame_rate_flag), AV_OPT_TYPE_INT,
673  { .i64 = -1 }, -1, 1, FLAGS },
674 
675  { "crop_left", "Set left border crop offset",
676  OFFSET(crop_left), AV_OPT_TYPE_INT,
677  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
678  { "crop_right", "Set right border crop offset",
679  OFFSET(crop_right), AV_OPT_TYPE_INT,
680  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
681  { "crop_top", "Set top border crop offset",
682  OFFSET(crop_top), AV_OPT_TYPE_INT,
683  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
684  { "crop_bottom", "Set bottom border crop offset",
685  OFFSET(crop_bottom), AV_OPT_TYPE_INT,
686  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
687 
688  { "sei_user_data", "Insert SEI user data (UUID+string)",
689  OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
690 
691  { "delete_filler", "Delete all filler (both NAL and SEI)",
692  OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
693 
694  { "display_orientation", "Display orientation SEI",
695  OFFSET(display_orientation), AV_OPT_TYPE_INT,
696  { .i64 = PASS }, PASS, EXTRACT, FLAGS, "disp_or" },
697  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
698  { .i64 = PASS }, .flags = FLAGS, .unit = "disp_or" },
699  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
700  { .i64 = INSERT }, .flags = FLAGS, .unit = "disp_or" },
701  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
702  { .i64 = REMOVE }, .flags = FLAGS, .unit = "disp_or" },
703  { "extract", NULL, 0, AV_OPT_TYPE_CONST,
704  { .i64 = EXTRACT }, .flags = FLAGS, .unit = "disp_or" },
705 
706  { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
707  OFFSET(rotate), AV_OPT_TYPE_DOUBLE,
708  { .dbl = NAN }, -360.0, +360.0, FLAGS },
709  { "flip", "Set flip in display orientation SEI",
711  { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
712  { "horizontal", "Set hor_flip",
714  { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
715  { "vertical", "Set ver_flip",
717  { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
718 
719  { "level", "Set level (table A-1)",
721  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
722  { "auto", "Attempt to guess level from stream properties",
724  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
725 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
726  { .i64 = value }, .flags = FLAGS, .unit = "level"
727  { LEVEL("1", 10) },
728  { LEVEL("1b", 9) },
729  { LEVEL("1.1", 11) },
730  { LEVEL("1.2", 12) },
731  { LEVEL("1.3", 13) },
732  { LEVEL("2", 20) },
733  { LEVEL("2.1", 21) },
734  { LEVEL("2.2", 22) },
735  { LEVEL("3", 30) },
736  { LEVEL("3.1", 31) },
737  { LEVEL("3.2", 32) },
738  { LEVEL("4", 40) },
739  { LEVEL("4.1", 41) },
740  { LEVEL("4.2", 42) },
741  { LEVEL("5", 50) },
742  { LEVEL("5.1", 51) },
743  { LEVEL("5.2", 52) },
744  { LEVEL("6", 60) },
745  { LEVEL("6.1", 61) },
746  { LEVEL("6.2", 62) },
747 #undef LEVEL
748 
749  { NULL }
750 };
751 
752 static const AVClass h264_metadata_class = {
753  .class_name = "h264_metadata_bsf",
754  .item_name = av_default_item_name,
755  .option = h264_metadata_options,
756  .version = LIBAVUTIL_VERSION_INT,
757 };
758 
759 static const enum AVCodecID h264_metadata_codec_ids[] = {
761 };
762 
764  .name = "h264_metadata",
765  .priv_data_size = sizeof(H264MetadataContext),
766  .priv_class = &h264_metadata_class,
768  .close = &h264_metadata_close,
771 };
ff_h264_metadata_bsf
const AVBitStreamFilter ff_h264_metadata_bsf
Definition: h264_metadata_bsf.c:763
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
av_isxdigit
static av_const int av_isxdigit(int c)
Locale-independent conversion of ASCII isxdigit.
Definition: avstring.h:251
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5791
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
level
uint8_t level
Definition: svq3.c:207
FLAGS
#define FLAGS
Definition: h264_metadata_bsf.c:632
H264RawSEIUserDataUnregistered::data_length
size_t data_length
Definition: cbs_h264.h:288
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
av_buffer_alloc
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
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
opt.h
H264MetadataContext::video_full_range_flag
int video_full_range_flag
Definition: h264_metadata_bsf.c:61
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
H264MetadataContext::sei_user_data
const char * sei_user_data
Definition: h264_metadata_bsf.c:76
H264RawSEIUserDataUnregistered::uuid_iso_iec_11578
uint8_t uuid_iso_iec_11578[16]
Definition: cbs_h264.h:286
LEVEL
#define LEVEL(name, value)
h264_levels.h
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:89
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
H264_NAL_FILLER_DATA
@ H264_NAL_FILLER_DATA
Definition: h264.h:46
ff_cbs_read_extradata
int ff_cbs_read_extradata(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecParameters *par)
Read the extradata bitstream found in codec parameters into a fragment, then split into units and dec...
Definition: cbs.c:224
cbs_h264.h
dpb_frames
int dpb_frames
Definition: h264_levels.c:159
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:101
AVBitStreamFilter::name
const char * name
Definition: avcodec.h:5813
ff_cbs_h264_delete_sei_message
void ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *access_unit, CodedBitstreamUnit *nal_unit, int position)
Delete an SEI message from an access unit.
Definition: cbs_h2645.c:1581
h264_metadata_options
static const AVOption h264_metadata_options[]
Definition: h264_metadata_bsf.c:633
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:65
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:168
level_idc
int level_idc
Definition: h264_levels.c:25
ff_cbs_close
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:115
AVOption
AVOption.
Definition: opt.h:246
ff_cbs_h264_add_sei_message
int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *access_unit, const H264RawSEIPayload *payload)
Add an SEI message to an access unit.
Definition: cbs_h2645.c:1519
data
const char data[16]
Definition: mxf.c:91
INSERT
@ INSERT
Definition: h264_metadata_bsf.c:33
ff_cbs_fragment_free
void ff_cbs_fragment_free(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:157
FLIP_HORIZONTAL
@ FLIP_HORIZONTAL
Definition: h264_metadata_bsf.c:39
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
h264_metadata_update_sps
static int h264_metadata_update_sps(AVBSFContext *bsf, H264RawSPS *sps)
Definition: h264_metadata_bsf.c:88
cbs.h
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure counterclockwise rotation by the specified angle...
Definition: display.c:50
H264MetadataContext::chroma_sample_loc_type
int chroma_sample_loc_type
Definition: h264_metadata_bsf.c:66
filter
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
Definition: filter_design.txt:228
H264MetadataContext::crop_top
int crop_top
Definition: h264_metadata_bsf.c:73
H264MetadataContext::crop_right
int crop_right
Definition: h264_metadata_bsf.c:72
H264LevelDescriptor
Definition: h264_levels.h:25
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:228
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
AVBSFContext
The bitstream filter state.
Definition: avcodec.h:5763
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
framerate
int framerate
Definition: h264_levels.c:65
h264_metadata_filter
static int h264_metadata_filter(AVBSFContext *bsf, AVPacket *pkt)
Definition: h264_metadata_bsf.c:286
bsf.h
av_packet_add_side_data
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:295
ff_h264_guess_level
const H264LevelDescriptor * ff_h264_guess_level(int profile_idc, int64_t bitrate, int framerate, int width, int height, int max_dec_frame_buffering)
Guess the level of a stream from some parameters.
Definition: h264_levels.c:90
fail
#define fail()
Definition: checkasm.h:120
ff_cbs_write_extradata
int ff_cbs_write_extradata(CodedBitstreamContext *ctx, AVCodecParameters *par, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to the extradata in codec parameters.
Definition: cbs.c:376
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: avcodec.h:1252
AVBSFContext::par_out
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5797
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
H264RawSEIPayload
Definition: cbs_h264.h:321
H264MetadataContext::rotate
double rotate
Definition: h264_metadata_bsf.c:81
H264MetadataContext::display_orientation
int display_orientation
Definition: h264_metadata_bsf.c:80
CodedBitstreamFragment::units
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:162
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
H264RawSEIPayload::user_data_unregistered
H264RawSEIUserDataUnregistered user_data_unregistered
Definition: cbs_h264.h:330
H264MetadataContext::fixed_frame_rate_flag
int fixed_frame_rate_flag
Definition: h264_metadata_bsf.c:69
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
width
#define width
ff_cbs_write_packet
int ff_cbs_write_packet(CodedBitstreamContext *ctx, AVPacket *pkt, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to a packet.
Definition: cbs.c:401
REMOVE
@ REMOVE
Definition: h264_metadata_bsf.c:34
H264MetadataContext::cbc
CodedBitstreamContext * cbc
Definition: h264_metadata_bsf.c:51
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:225
H264_MAX_WIDTH
@ H264_MAX_WIDTH
Definition: h264.h:108
H264MetadataContext::transfer_characteristics
int transfer_characteristics
Definition: h264_metadata_bsf.c:63
ctx
AVFormatContext * ctx
Definition: movenc.c:48
CROP
#define CROP(border, unit)
PASS
@ PASS
Definition: h264_metadata_bsf.c:32
H264RawSEIDisplayOrientation::display_orientation_repetition_period
uint16_t display_orientation_repetition_period
Definition: cbs_h264.h:304
ff_cbs_delete_unit
void ff_cbs_delete_unit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
Definition: cbs.c:796
NAN
#define NAN
Definition: mathematics.h:64
FLIP_VERTICAL
@ FLIP_VERTICAL
Definition: h264_metadata_bsf.c:40
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: avcodec.h:245
int32_t
int32_t
Definition: audio_convert.c:194
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
H264RawSEIUserDataUnregistered
Definition: cbs_h264.h:285
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
rint
#define rint
Definition: tablegen.h:41
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
H264RawSEIDisplayOrientation::anticlockwise_rotation
uint16_t anticlockwise_rotation
Definition: cbs_h264.h:303
isnan
#define isnan(x)
Definition: libm.h:340
LEVEL_UNSET
@ LEVEL_UNSET
Definition: h264_metadata_bsf.c:44
H264MetadataContext::delete_filler
int delete_filler
Definition: h264_metadata_bsf.c:78
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
H264MetadataContext::crop_bottom
int crop_bottom
Definition: h264_metadata_bsf.c:74
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:924
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
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
H264MetadataContext::access_unit
CodedBitstreamFragment access_unit
Definition: h264_metadata_bsf.c:52
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:1006
H264RawSEIUserDataUnregistered::data_ref
AVBufferRef * data_ref
Definition: cbs_h264.h:289
H264MetadataContext::flip
int flip
Definition: h264_metadata_bsf.c:82
H264RawSEIDisplayOrientation::hor_flip
uint8_t hor_flip
Definition: cbs_h264.h:301
desc
const char * desc
Definition: nvenc.c:68
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:136
H264RawSliceHeader::slice_type
uint8_t slice_type
Definition: cbs_h264.h:355
size
int size
Definition: twinvq_data.h:11134
H264RawSEIUserDataUnregistered::data
uint8_t * data
Definition: cbs_h264.h:287
EXTRACT
@ EXTRACT
Definition: h264_metadata_bsf.c:35
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:176
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
H264RawSEIDisplayOrientation
Definition: cbs_h264.h:299
LEVEL_AUTO
@ LEVEL_AUTO
Definition: h264_metadata_bsf.c:45
height
#define height
H264MetadataContext::aud
int aud
Definition: h264_metadata_bsf.c:56
H264_SEI_TYPE_USER_DATA_UNREGISTERED
@ H264_SEI_TYPE_USER_DATA_UNREGISTERED
unregistered user data
Definition: h264_sei.h:33
H264_SEI_TYPE_FILLER_PAYLOAD
@ H264_SEI_TYPE_FILLER_PAYLOAD
filler data
Definition: h264_sei.h:31
h264_metadata_init
static int h264_metadata_init(AVBSFContext *bsf)
Definition: h264_metadata_bsf.c:585
H264MetadataContext::colour_primaries
int colour_primaries
Definition: h264_metadata_bsf.c:62
H264MetadataContext
Definition: h264_metadata_bsf.c:48
OFFSET
#define OFFSET(x)
Definition: h264_metadata_bsf.c:631
h264_sei.h
H264RawSlice::header
H264RawSliceHeader header
Definition: cbs_h264.h:430
h264_metadata_class
static const AVClass h264_metadata_class
Definition: h264_metadata_bsf.c:752
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: avcodec.h:216
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
display.h
common.h
h264_metadata_codec_ids
static enum AVCodecID h264_metadata_codec_ids[]
Definition: h264_metadata_bsf.c:759
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40
uint8_t
uint8_t
Definition: audio_convert.c:194
len
int len
Definition: vorbis_enc_data.h:452
H264_SEI_TYPE_DISPLAY_ORIENTATION
@ H264_SEI_TYPE_DISPLAY_ORIENTATION
display orientation
Definition: h264_sei.h:36
H264_MAX_HEIGHT
@ H264_MAX_HEIGHT
Definition: h264.h:109
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5784
SET_OR_INFER
#define SET_OR_INFER(field, value, present_flag, infer)
H264RawSEI
Definition: cbs_h264.h:344
H264RawSEIDisplayOrientation::ver_flip
uint8_t ver_flip
Definition: cbs_h264.h:302
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
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:72
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
ff_cbs_init
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:74
H264RawSEIPayload::display_orientation
H264RawSEIDisplayOrientation display_orientation
Definition: cbs_h264.h:332
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
H264MetadataContext::video_format
int video_format
Definition: h264_metadata_bsf.c:60
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
H264RawAUD
Definition: cbs_h264.h:227
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVBitStreamFilter
Definition: avcodec.h:5812
H264MetadataContext::matrix_coefficients
int matrix_coefficients
Definition: h264_metadata_bsf.c:64
H264MetadataContext::done_first_au
int done_first_au
Definition: h264_metadata_bsf.c:54
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
ff_cbs_fragment_reset
void ff_cbs_fragment_reset(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
Definition: cbs.c:142
H264MetadataContext::tick_rate
AVRational tick_rate
Definition: h264_metadata_bsf.c:68
ff_cbs_read_packet
int ff_cbs_read_packet(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)
Read the data bitstream from a packet into a fragment, then split into units and decompose.
Definition: cbs.c:242
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, 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:722
codec_ids
static enum AVCodecID codec_ids[]
Definition: aac_adtstoasc_bsf.c:148
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
H264MetadataContext::level
int level
Definition: h264_metadata_bsf.c:84
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:222
h264.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_bsf_get_packet_ref
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:239
H264MetadataContext::sample_aspect_ratio
AVRational sample_aspect_ratio
Definition: h264_metadata_bsf.c:58
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:227
H264MetadataContext::crop_left
int crop_left
Definition: h264_metadata_bsf.c:71
H264RawSEIPayload::payload
union H264RawSEIPayload::@51 payload
H264RawSEIPayload::payload_type
uint32_t payload_type
Definition: cbs_h264.h:322
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
h264_metadata_close
static void h264_metadata_close(AVBSFContext *bsf)
Definition: h264_metadata_bsf.c:623
av_tolower
static av_const int av_tolower(int c)
Locale-independent conversion of ASCII characters to lowercase.
Definition: avstring.h:241
CodedBitstreamFragment::nb_units
int nb_units
Number of units in this fragment.
Definition: cbs.h:147
av_display_rotation_get
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
H264RawSlice
Definition: cbs_h264.h:429
H264RawSPS
Definition: cbs_h264.h:111