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