2 * This file is part of FFmpeg.
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.
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.
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
19 static int FUNC(obu_header
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
20 AV1RawOBUHeader
*current
)
22 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
27 fc(1, obu_forbidden_bit
, 0, 0);
29 fc(4, obu_type
, 0, AV1_OBU_PADDING
);
30 flag(obu_extension_flag
);
31 flag(obu_has_size_field
);
33 fc(1, obu_reserved_1bit
, 0, 0);
35 if (current
->obu_extension_flag
) {
38 fc(3, extension_header_reserved_3bits
, 0, 0);
40 infer(temporal_id
, 0);
44 priv
->temporal_id
= current
->temporal_id
;
45 priv
->spatial_id
= current
->spatial_id
;
50 static int FUNC(trailing_bits
)(CodedBitstreamContext
*ctx
, RWContext
*rw
, int nb_bits
)
54 av_assert0(nb_bits
> 0);
56 fixed(1, trailing_one_bit
, 1);
60 fixed(1, trailing_zero_bit
, 0);
67 static int FUNC(byte_alignment
)(CodedBitstreamContext
*ctx
, RWContext
*rw
)
71 while (byte_alignment(rw
) != 0)
72 fixed(1, zero_bit
, 0);
77 static int FUNC(color_config
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
78 AV1RawColorConfig
*current
, int seq_profile
)
80 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
85 if (seq_profile
== AV_PROFILE_AV1_PROFESSIONAL
&&
86 current
->high_bitdepth
) {
88 priv
->bit_depth
= current
->twelve_bit
? 12 : 10;
90 priv
->bit_depth
= current
->high_bitdepth
? 10 : 8;
93 if (seq_profile
== AV_PROFILE_AV1_HIGH
)
94 infer(mono_chrome
, 0);
97 priv
->num_planes
= current
->mono_chrome
? 1 : 3;
99 flag(color_description_present_flag
);
100 if (current
->color_description_present_flag
) {
101 fb(8, color_primaries
);
102 fb(8, transfer_characteristics
);
103 fb(8, matrix_coefficients
);
105 infer(color_primaries
, AVCOL_PRI_UNSPECIFIED
);
106 infer(transfer_characteristics
, AVCOL_TRC_UNSPECIFIED
);
107 infer(matrix_coefficients
, AVCOL_SPC_UNSPECIFIED
);
110 if (current
->mono_chrome
) {
113 infer(subsampling_x
, 1);
114 infer(subsampling_y
, 1);
115 infer(chroma_sample_position
, AV1_CSP_UNKNOWN
);
116 infer(separate_uv_delta_q
, 0);
118 } else if (current
->color_primaries
== AVCOL_PRI_BT709
&&
119 current
->transfer_characteristics
== AVCOL_TRC_IEC61966_2_1
&&
120 current
->matrix_coefficients
== AVCOL_SPC_RGB
) {
121 infer(color_range
, 1);
122 infer(subsampling_x
, 0);
123 infer(subsampling_y
, 0);
124 flag(separate_uv_delta_q
);
129 if (seq_profile
== AV_PROFILE_AV1_MAIN
) {
130 infer(subsampling_x
, 1);
131 infer(subsampling_y
, 1);
132 } else if (seq_profile
== AV_PROFILE_AV1_HIGH
) {
133 infer(subsampling_x
, 0);
134 infer(subsampling_y
, 0);
136 if (priv
->bit_depth
== 12) {
137 fb(1, subsampling_x
);
138 if (current
->subsampling_x
)
139 fb(1, subsampling_y
);
141 infer(subsampling_y
, 0);
143 infer(subsampling_x
, 1);
144 infer(subsampling_y
, 0);
147 if (current
->subsampling_x
&& current
->subsampling_y
) {
148 fc(2, chroma_sample_position
, AV1_CSP_UNKNOWN
,
152 flag(separate_uv_delta_q
);
158 static int FUNC(timing_info
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
159 AV1RawTimingInfo
*current
)
163 fc(32, num_units_in_display_tick
, 1, MAX_UINT_BITS(32));
164 fc(32, time_scale
, 1, MAX_UINT_BITS(32));
166 flag(equal_picture_interval
);
167 if (current
->equal_picture_interval
)
168 uvlc(num_ticks_per_picture_minus_1
, 0, MAX_UINT_BITS(32) - 1);
173 static int FUNC(decoder_model_info
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
174 AV1RawDecoderModelInfo
*current
)
178 fb(5, buffer_delay_length_minus_1
);
179 fc(32, num_units_in_decoding_tick
, 1, MAX_UINT_BITS(32));
180 fb(5, buffer_removal_time_length_minus_1
);
181 fb(5, frame_presentation_time_length_minus_1
);
186 static int FUNC(sequence_header_obu
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
187 AV1RawSequenceHeader
*current
)
191 HEADER("Sequence Header");
193 fc(3, seq_profile
, AV_PROFILE_AV1_MAIN
,
194 AV_PROFILE_AV1_PROFESSIONAL
);
196 flag(reduced_still_picture_header
);
198 if (current
->reduced_still_picture_header
) {
199 infer(timing_info_present_flag
, 0);
200 infer(decoder_model_info_present_flag
, 0);
201 infer(initial_display_delay_present_flag
, 0);
202 infer(operating_points_cnt_minus_1
, 0);
203 infer(operating_point_idc
[0], 0);
205 fb(5, seq_level_idx
[0]);
207 infer(seq_tier
[0], 0);
208 infer(decoder_model_present_for_this_op
[0], 0);
209 infer(initial_display_delay_present_for_this_op
[0], 0);
212 flag(timing_info_present_flag
);
213 if (current
->timing_info_present_flag
) {
214 CHECK(FUNC(timing_info
)(ctx
, rw
, ¤t
->timing_info
));
216 flag(decoder_model_info_present_flag
);
217 if (current
->decoder_model_info_present_flag
) {
218 CHECK(FUNC(decoder_model_info
)
219 (ctx
, rw
, ¤t
->decoder_model_info
));
222 infer(decoder_model_info_present_flag
, 0);
225 flag(initial_display_delay_present_flag
);
227 fb(5, operating_points_cnt_minus_1
);
228 for (i
= 0; i
<= current
->operating_points_cnt_minus_1
; i
++) {
229 fbs(12, operating_point_idc
[i
], 1, i
);
230 fbs(5, seq_level_idx
[i
], 1, i
);
232 if (current
->seq_level_idx
[i
] > 7)
233 flags(seq_tier
[i
], 1, i
);
235 infer(seq_tier
[i
], 0);
237 if (current
->decoder_model_info_present_flag
) {
238 flags(decoder_model_present_for_this_op
[i
], 1, i
);
239 if (current
->decoder_model_present_for_this_op
[i
]) {
240 int n
= current
->decoder_model_info
.buffer_delay_length_minus_1
+ 1;
241 fbs(n
, decoder_buffer_delay
[i
], 1, i
);
242 fbs(n
, encoder_buffer_delay
[i
], 1, i
);
243 flags(low_delay_mode_flag
[i
], 1, i
);
246 infer(decoder_model_present_for_this_op
[i
], 0);
249 if (current
->initial_display_delay_present_flag
) {
250 flags(initial_display_delay_present_for_this_op
[i
], 1, i
);
251 if (current
->initial_display_delay_present_for_this_op
[i
])
252 fbs(4, initial_display_delay_minus_1
[i
], 1, i
);
257 fb(4, frame_width_bits_minus_1
);
258 fb(4, frame_height_bits_minus_1
);
260 fb(current
->frame_width_bits_minus_1
+ 1, max_frame_width_minus_1
);
261 fb(current
->frame_height_bits_minus_1
+ 1, max_frame_height_minus_1
);
263 if (current
->reduced_still_picture_header
)
264 infer(frame_id_numbers_present_flag
, 0);
266 flag(frame_id_numbers_present_flag
);
267 if (current
->frame_id_numbers_present_flag
) {
268 fb(4, delta_frame_id_length_minus_2
);
269 fb(3, additional_frame_id_length_minus_1
);
272 flag(use_128x128_superblock
);
273 flag(enable_filter_intra
);
274 flag(enable_intra_edge_filter
);
276 if (current
->reduced_still_picture_header
) {
277 infer(enable_interintra_compound
, 0);
278 infer(enable_masked_compound
, 0);
279 infer(enable_warped_motion
, 0);
280 infer(enable_dual_filter
, 0);
281 infer(enable_order_hint
, 0);
282 infer(enable_jnt_comp
, 0);
283 infer(enable_ref_frame_mvs
, 0);
285 infer(seq_force_screen_content_tools
,
286 AV1_SELECT_SCREEN_CONTENT_TOOLS
);
287 infer(seq_force_integer_mv
,
288 AV1_SELECT_INTEGER_MV
);
290 flag(enable_interintra_compound
);
291 flag(enable_masked_compound
);
292 flag(enable_warped_motion
);
293 flag(enable_dual_filter
);
295 flag(enable_order_hint
);
296 if (current
->enable_order_hint
) {
297 flag(enable_jnt_comp
);
298 flag(enable_ref_frame_mvs
);
300 infer(enable_jnt_comp
, 0);
301 infer(enable_ref_frame_mvs
, 0);
304 flag(seq_choose_screen_content_tools
);
305 if (current
->seq_choose_screen_content_tools
)
306 infer(seq_force_screen_content_tools
,
307 AV1_SELECT_SCREEN_CONTENT_TOOLS
);
309 fb(1, seq_force_screen_content_tools
);
310 if (current
->seq_force_screen_content_tools
> 0) {
311 flag(seq_choose_integer_mv
);
312 if (current
->seq_choose_integer_mv
)
313 infer(seq_force_integer_mv
,
314 AV1_SELECT_INTEGER_MV
);
316 fb(1, seq_force_integer_mv
);
318 infer(seq_force_integer_mv
, AV1_SELECT_INTEGER_MV
);
321 if (current
->enable_order_hint
)
322 fb(3, order_hint_bits_minus_1
);
325 flag(enable_superres
);
327 flag(enable_restoration
);
329 CHECK(FUNC(color_config
)(ctx
, rw
, ¤t
->color_config
,
330 current
->seq_profile
));
332 flag(film_grain_params_present
);
337 static int FUNC(temporal_delimiter_obu
)(CodedBitstreamContext
*ctx
, RWContext
*rw
)
339 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
341 HEADER("Temporal Delimiter");
343 priv
->seen_frame_header
= 0;
348 static int FUNC(set_frame_refs
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
349 AV1RawFrameHeader
*current
)
351 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
352 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
353 static const uint8_t ref_frame_list
[AV1_NUM_REF_FRAMES
- 2] = {
354 AV1_REF_FRAME_LAST2
, AV1_REF_FRAME_LAST3
, AV1_REF_FRAME_BWDREF
,
355 AV1_REF_FRAME_ALTREF2
, AV1_REF_FRAME_ALTREF
357 int8_t ref_frame_idx
[AV1_REFS_PER_FRAME
], used_frame
[AV1_NUM_REF_FRAMES
];
358 int16_t shifted_order_hints
[AV1_NUM_REF_FRAMES
];
359 int cur_frame_hint
, latest_order_hint
, earliest_order_hint
, ref
;
362 for (i
= 0; i
< AV1_REFS_PER_FRAME
; i
++)
363 ref_frame_idx
[i
] = -1;
364 ref_frame_idx
[AV1_REF_FRAME_LAST
- AV1_REF_FRAME_LAST
] = current
->last_frame_idx
;
365 ref_frame_idx
[AV1_REF_FRAME_GOLDEN
- AV1_REF_FRAME_LAST
] = current
->golden_frame_idx
;
367 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++)
369 used_frame
[current
->last_frame_idx
] = 1;
370 used_frame
[current
->golden_frame_idx
] = 1;
372 cur_frame_hint
= 1 << (seq
->order_hint_bits_minus_1
);
373 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++)
374 shifted_order_hints
[i
] = cur_frame_hint
+
375 cbs_av1_get_relative_dist(seq
, priv
->ref
[i
].order_hint
,
378 latest_order_hint
= shifted_order_hints
[current
->last_frame_idx
];
379 earliest_order_hint
= shifted_order_hints
[current
->golden_frame_idx
];
382 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++) {
383 int hint
= shifted_order_hints
[i
];
384 if (!used_frame
[i
] && hint
>= cur_frame_hint
&&
385 (ref
< 0 || hint
>= latest_order_hint
)) {
387 latest_order_hint
= hint
;
391 ref_frame_idx
[AV1_REF_FRAME_ALTREF
- AV1_REF_FRAME_LAST
] = ref
;
396 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++) {
397 int hint
= shifted_order_hints
[i
];
398 if (!used_frame
[i
] && hint
>= cur_frame_hint
&&
399 (ref
< 0 || hint
< earliest_order_hint
)) {
401 earliest_order_hint
= hint
;
405 ref_frame_idx
[AV1_REF_FRAME_BWDREF
- AV1_REF_FRAME_LAST
] = ref
;
410 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++) {
411 int hint
= shifted_order_hints
[i
];
412 if (!used_frame
[i
] && hint
>= cur_frame_hint
&&
413 (ref
< 0 || hint
< earliest_order_hint
)) {
415 earliest_order_hint
= hint
;
419 ref_frame_idx
[AV1_REF_FRAME_ALTREF2
- AV1_REF_FRAME_LAST
] = ref
;
423 for (i
= 0; i
< AV1_REFS_PER_FRAME
- 2; i
++) {
424 int ref_frame
= ref_frame_list
[i
];
425 if (ref_frame_idx
[ref_frame
- AV1_REF_FRAME_LAST
] < 0 ) {
427 for (j
= 0; j
< AV1_NUM_REF_FRAMES
; j
++) {
428 int hint
= shifted_order_hints
[j
];
429 if (!used_frame
[j
] && hint
< cur_frame_hint
&&
430 (ref
< 0 || hint
>= latest_order_hint
)) {
432 latest_order_hint
= hint
;
436 ref_frame_idx
[ref_frame
- AV1_REF_FRAME_LAST
] = ref
;
443 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++) {
444 int hint
= shifted_order_hints
[i
];
445 if (ref
< 0 || hint
< earliest_order_hint
) {
447 earliest_order_hint
= hint
;
450 for (i
= 0; i
< AV1_REFS_PER_FRAME
; i
++) {
451 if (ref_frame_idx
[i
] < 0)
452 ref_frame_idx
[i
] = ref
;
453 infer(ref_frame_idx
[i
], ref_frame_idx
[i
]);
459 static int FUNC(superres_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
460 AV1RawFrameHeader
*current
)
462 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
463 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
466 if (seq
->enable_superres
)
469 infer(use_superres
, 0);
471 if (current
->use_superres
) {
473 denom
= current
->coded_denom
+ AV1_SUPERRES_DENOM_MIN
;
475 denom
= AV1_SUPERRES_NUM
;
478 priv
->upscaled_width
= priv
->frame_width
;
479 priv
->frame_width
= (priv
->upscaled_width
* AV1_SUPERRES_NUM
+
485 static int FUNC(frame_size
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
486 AV1RawFrameHeader
*current
)
488 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
489 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
492 if (current
->frame_size_override_flag
) {
493 fb(seq
->frame_width_bits_minus_1
+ 1, frame_width_minus_1
);
494 fb(seq
->frame_height_bits_minus_1
+ 1, frame_height_minus_1
);
496 infer(frame_width_minus_1
, seq
->max_frame_width_minus_1
);
497 infer(frame_height_minus_1
, seq
->max_frame_height_minus_1
);
500 priv
->frame_width
= current
->frame_width_minus_1
+ 1;
501 priv
->frame_height
= current
->frame_height_minus_1
+ 1;
503 CHECK(FUNC(superres_params
)(ctx
, rw
, current
));
508 static int FUNC(render_size
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
509 AV1RawFrameHeader
*current
)
511 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
514 flag(render_and_frame_size_different
);
516 if (current
->render_and_frame_size_different
) {
517 fb(16, render_width_minus_1
);
518 fb(16, render_height_minus_1
);
520 infer(render_width_minus_1
, current
->frame_width_minus_1
);
521 infer(render_height_minus_1
, current
->frame_height_minus_1
);
524 priv
->render_width
= current
->render_width_minus_1
+ 1;
525 priv
->render_height
= current
->render_height_minus_1
+ 1;
530 static int FUNC(frame_size_with_refs
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
531 AV1RawFrameHeader
*current
)
533 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
536 for (i
= 0; i
< AV1_REFS_PER_FRAME
; i
++) {
537 flags(found_ref
[i
], 1, i
);
538 if (current
->found_ref
[i
]) {
539 AV1ReferenceFrameState
*ref
=
540 &priv
->ref
[current
->ref_frame_idx
[i
]];
543 av_log(ctx
->log_ctx
, AV_LOG_ERROR
,
544 "Missing reference frame needed for frame size "
545 "(ref = %d, ref_frame_idx = %d).\n",
546 i
, current
->ref_frame_idx
[i
]);
547 return AVERROR_INVALIDDATA
;
550 infer(frame_width_minus_1
, ref
->upscaled_width
- 1);
551 infer(frame_height_minus_1
, ref
->frame_height
- 1);
552 infer(render_width_minus_1
, ref
->render_width
- 1);
553 infer(render_height_minus_1
, ref
->render_height
- 1);
555 priv
->upscaled_width
= ref
->upscaled_width
;
556 priv
->frame_width
= priv
->upscaled_width
;
557 priv
->frame_height
= ref
->frame_height
;
558 priv
->render_width
= ref
->render_width
;
559 priv
->render_height
= ref
->render_height
;
564 if (i
>= AV1_REFS_PER_FRAME
) {
565 CHECK(FUNC(frame_size
)(ctx
, rw
, current
));
566 CHECK(FUNC(render_size
)(ctx
, rw
, current
));
568 CHECK(FUNC(superres_params
)(ctx
, rw
, current
));
574 static int FUNC(interpolation_filter
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
575 AV1RawFrameHeader
*current
)
579 flag(is_filter_switchable
);
580 if (current
->is_filter_switchable
)
581 infer(interpolation_filter
,
582 AV1_INTERPOLATION_FILTER_SWITCHABLE
);
584 fb(2, interpolation_filter
);
589 static int FUNC(tile_info
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
590 AV1RawFrameHeader
*current
)
592 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
593 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
594 int mi_cols
, mi_rows
, sb_cols
, sb_rows
, sb_shift
, sb_size
;
595 int max_tile_width_sb
, max_tile_height_sb
, max_tile_area_sb
;
596 int min_log2_tile_cols
, max_log2_tile_cols
, max_log2_tile_rows
;
597 int min_log2_tiles
, min_log2_tile_rows
;
600 mi_cols
= 2 * ((priv
->frame_width
+ 7) >> 3);
601 mi_rows
= 2 * ((priv
->frame_height
+ 7) >> 3);
603 sb_cols
= seq
->use_128x128_superblock
? ((mi_cols
+ 31) >> 5)
604 : ((mi_cols
+ 15) >> 4);
605 sb_rows
= seq
->use_128x128_superblock
? ((mi_rows
+ 31) >> 5)
606 : ((mi_rows
+ 15) >> 4);
608 sb_shift
= seq
->use_128x128_superblock
? 5 : 4;
609 sb_size
= sb_shift
+ 2;
611 max_tile_width_sb
= AV1_MAX_TILE_WIDTH
>> sb_size
;
612 max_tile_area_sb
= AV1_MAX_TILE_AREA
>> (2 * sb_size
);
614 min_log2_tile_cols
= cbs_av1_tile_log2(max_tile_width_sb
, sb_cols
);
615 max_log2_tile_cols
= cbs_av1_tile_log2(1, FFMIN(sb_cols
, AV1_MAX_TILE_COLS
));
616 max_log2_tile_rows
= cbs_av1_tile_log2(1, FFMIN(sb_rows
, AV1_MAX_TILE_ROWS
));
617 min_log2_tiles
= FFMAX(min_log2_tile_cols
,
618 cbs_av1_tile_log2(max_tile_area_sb
, sb_rows
* sb_cols
));
620 flag(uniform_tile_spacing_flag
);
622 if (current
->uniform_tile_spacing_flag
) {
623 int tile_width_sb
, tile_height_sb
;
625 increment(tile_cols_log2
, min_log2_tile_cols
, max_log2_tile_cols
);
627 tile_width_sb
= (sb_cols
+ (1 << current
->tile_cols_log2
) - 1) >>
628 current
->tile_cols_log2
;
630 for (int off
= 0, i
= 0; off
< sb_cols
; off
+= tile_width_sb
)
631 current
->tile_start_col_sb
[i
++] = off
;
633 current
->tile_cols
= (sb_cols
+ tile_width_sb
- 1) / tile_width_sb
;
635 min_log2_tile_rows
= FFMAX(min_log2_tiles
- current
->tile_cols_log2
, 0);
637 increment(tile_rows_log2
, min_log2_tile_rows
, max_log2_tile_rows
);
639 tile_height_sb
= (sb_rows
+ (1 << current
->tile_rows_log2
) - 1) >>
640 current
->tile_rows_log2
;
642 for (int off
= 0, i
= 0; off
< sb_rows
; off
+= tile_height_sb
)
643 current
->tile_start_row_sb
[i
++] = off
;
645 current
->tile_rows
= (sb_rows
+ tile_height_sb
- 1) / tile_height_sb
;
647 for (i
= 0; i
< current
->tile_cols
- 1; i
++)
648 infer(width_in_sbs_minus_1
[i
], tile_width_sb
- 1);
649 infer(width_in_sbs_minus_1
[i
],
650 sb_cols
- (current
->tile_cols
- 1) * tile_width_sb
- 1);
651 for (i
= 0; i
< current
->tile_rows
- 1; i
++)
652 infer(height_in_sbs_minus_1
[i
], tile_height_sb
- 1);
653 infer(height_in_sbs_minus_1
[i
],
654 sb_rows
- (current
->tile_rows
- 1) * tile_height_sb
- 1);
657 int widest_tile_sb
, start_sb
, size_sb
, max_width
, max_height
;
662 for (i
= 0; start_sb
< sb_cols
&& i
< AV1_MAX_TILE_COLS
; i
++) {
663 current
->tile_start_col_sb
[i
] = start_sb
;
664 max_width
= FFMIN(sb_cols
- start_sb
, max_tile_width_sb
);
665 ns(max_width
, width_in_sbs_minus_1
[i
], 1, i
);
666 size_sb
= current
->width_in_sbs_minus_1
[i
] + 1;
667 widest_tile_sb
= FFMAX(size_sb
, widest_tile_sb
);
670 current
->tile_cols_log2
= cbs_av1_tile_log2(1, i
);
671 current
->tile_cols
= i
;
673 if (min_log2_tiles
> 0)
674 max_tile_area_sb
= (sb_rows
* sb_cols
) >> (min_log2_tiles
+ 1);
676 max_tile_area_sb
= sb_rows
* sb_cols
;
677 max_tile_height_sb
= FFMAX(max_tile_area_sb
/ widest_tile_sb
, 1);
680 for (i
= 0; start_sb
< sb_rows
&& i
< AV1_MAX_TILE_ROWS
; i
++) {
681 current
->tile_start_row_sb
[i
] = start_sb
;
682 max_height
= FFMIN(sb_rows
- start_sb
, max_tile_height_sb
);
683 ns(max_height
, height_in_sbs_minus_1
[i
], 1, i
);
684 size_sb
= current
->height_in_sbs_minus_1
[i
] + 1;
687 current
->tile_rows_log2
= cbs_av1_tile_log2(1, i
);
688 current
->tile_rows
= i
;
691 if (current
->tile_cols_log2
> 0 ||
692 current
->tile_rows_log2
> 0) {
693 fb(current
->tile_cols_log2
+ current
->tile_rows_log2
,
694 context_update_tile_id
);
695 fb(2, tile_size_bytes_minus1
);
697 infer(context_update_tile_id
, 0);
700 priv
->tile_cols
= current
->tile_cols
;
701 priv
->tile_rows
= current
->tile_rows
;
706 static int FUNC(quantization_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
707 AV1RawFrameHeader
*current
)
709 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
710 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
715 delta_q(delta_q_y_dc
);
717 if (priv
->num_planes
> 1) {
718 if (seq
->color_config
.separate_uv_delta_q
)
721 infer(diff_uv_delta
, 0);
723 delta_q(delta_q_u_dc
);
724 delta_q(delta_q_u_ac
);
726 if (current
->diff_uv_delta
) {
727 delta_q(delta_q_v_dc
);
728 delta_q(delta_q_v_ac
);
730 infer(delta_q_v_dc
, current
->delta_q_u_dc
);
731 infer(delta_q_v_ac
, current
->delta_q_u_ac
);
734 infer(delta_q_u_dc
, 0);
735 infer(delta_q_u_ac
, 0);
736 infer(delta_q_v_dc
, 0);
737 infer(delta_q_v_ac
, 0);
741 if (current
->using_qmatrix
) {
744 if (seq
->color_config
.separate_uv_delta_q
)
747 infer(qm_v
, current
->qm_u
);
753 static int FUNC(segmentation_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
754 AV1RawFrameHeader
*current
)
756 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
757 static const uint8_t bits
[AV1_SEG_LVL_MAX
] = { 8, 6, 6, 6, 6, 3, 0, 0 };
758 static const uint8_t sign
[AV1_SEG_LVL_MAX
] = { 1, 1, 1, 1, 1, 0, 0, 0 };
759 static const uint8_t default_feature_enabled
[AV1_SEG_LVL_MAX
] = { 0 };
760 static const int16_t default_feature_value
[AV1_SEG_LVL_MAX
] = { 0 };
763 flag(segmentation_enabled
);
765 if (current
->segmentation_enabled
) {
766 if (current
->primary_ref_frame
== AV1_PRIMARY_REF_NONE
) {
767 infer(segmentation_update_map
, 1);
768 infer(segmentation_temporal_update
, 0);
769 infer(segmentation_update_data
, 1);
771 flag(segmentation_update_map
);
772 if (current
->segmentation_update_map
)
773 flag(segmentation_temporal_update
);
775 infer(segmentation_temporal_update
, 0);
776 flag(segmentation_update_data
);
779 for (i
= 0; i
< AV1_MAX_SEGMENTS
; i
++) {
780 const uint8_t *ref_feature_enabled
;
781 const int16_t *ref_feature_value
;
783 if (current
->primary_ref_frame
== AV1_PRIMARY_REF_NONE
) {
784 ref_feature_enabled
= default_feature_enabled
;
785 ref_feature_value
= default_feature_value
;
787 ref_feature_enabled
=
788 priv
->ref
[current
->ref_frame_idx
[current
->primary_ref_frame
]].feature_enabled
[i
];
790 priv
->ref
[current
->ref_frame_idx
[current
->primary_ref_frame
]].feature_value
[i
];
793 for (j
= 0; j
< AV1_SEG_LVL_MAX
; j
++) {
794 if (current
->segmentation_update_data
) {
795 flags(feature_enabled
[i
][j
], 2, i
, j
);
797 if (current
->feature_enabled
[i
][j
] && bits
[j
] > 0) {
799 sus(1 + bits
[j
], feature_value
[i
][j
], 2, i
, j
);
801 fbs(bits
[j
], feature_value
[i
][j
], 2, i
, j
);
803 infer(feature_value
[i
][j
], 0);
806 infer(feature_enabled
[i
][j
], ref_feature_enabled
[j
]);
807 infer(feature_value
[i
][j
], ref_feature_value
[j
]);
812 for (i
= 0; i
< AV1_MAX_SEGMENTS
; i
++) {
813 for (j
= 0; j
< AV1_SEG_LVL_MAX
; j
++) {
814 infer(feature_enabled
[i
][j
], 0);
815 infer(feature_value
[i
][j
], 0);
823 static int FUNC(delta_q_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
824 AV1RawFrameHeader
*current
)
828 if (current
->base_q_idx
> 0)
829 flag(delta_q_present
);
831 infer(delta_q_present
, 0);
833 if (current
->delta_q_present
)
839 static int FUNC(delta_lf_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
840 AV1RawFrameHeader
*current
)
844 if (current
->delta_q_present
) {
845 if (!current
->allow_intrabc
)
846 flag(delta_lf_present
);
848 infer(delta_lf_present
, 0);
849 if (current
->delta_lf_present
) {
851 flag(delta_lf_multi
);
853 infer(delta_lf_res
, 0);
854 infer(delta_lf_multi
, 0);
857 infer(delta_lf_present
, 0);
858 infer(delta_lf_res
, 0);
859 infer(delta_lf_multi
, 0);
865 static int FUNC(loop_filter_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
866 AV1RawFrameHeader
*current
)
868 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
869 static const int8_t default_loop_filter_ref_deltas
[AV1_TOTAL_REFS_PER_FRAME
] =
870 { 1, 0, 0, 0, -1, 0, -1, -1 };
871 static const int8_t default_loop_filter_mode_deltas
[2] = { 0, 0 };
874 if (priv
->coded_lossless
|| current
->allow_intrabc
) {
875 infer(loop_filter_level
[0], 0);
876 infer(loop_filter_level
[1], 0);
877 infer(loop_filter_ref_deltas
[AV1_REF_FRAME_INTRA
], 1);
878 infer(loop_filter_ref_deltas
[AV1_REF_FRAME_LAST
], 0);
879 infer(loop_filter_ref_deltas
[AV1_REF_FRAME_LAST2
], 0);
880 infer(loop_filter_ref_deltas
[AV1_REF_FRAME_LAST3
], 0);
881 infer(loop_filter_ref_deltas
[AV1_REF_FRAME_BWDREF
], 0);
882 infer(loop_filter_ref_deltas
[AV1_REF_FRAME_GOLDEN
], -1);
883 infer(loop_filter_ref_deltas
[AV1_REF_FRAME_ALTREF
], -1);
884 infer(loop_filter_ref_deltas
[AV1_REF_FRAME_ALTREF2
], -1);
885 for (i
= 0; i
< 2; i
++)
886 infer(loop_filter_mode_deltas
[i
], 0);
890 fb(6, loop_filter_level
[0]);
891 fb(6, loop_filter_level
[1]);
893 if (priv
->num_planes
> 1) {
894 if (current
->loop_filter_level
[0] ||
895 current
->loop_filter_level
[1]) {
896 fb(6, loop_filter_level
[2]);
897 fb(6, loop_filter_level
[3]);
901 fb(3, loop_filter_sharpness
);
903 flag(loop_filter_delta_enabled
);
904 if (current
->loop_filter_delta_enabled
) {
905 const int8_t *ref_loop_filter_ref_deltas
, *ref_loop_filter_mode_deltas
;
907 if (current
->primary_ref_frame
== AV1_PRIMARY_REF_NONE
) {
908 ref_loop_filter_ref_deltas
= default_loop_filter_ref_deltas
;
909 ref_loop_filter_mode_deltas
= default_loop_filter_mode_deltas
;
911 ref_loop_filter_ref_deltas
=
912 priv
->ref
[current
->ref_frame_idx
[current
->primary_ref_frame
]].loop_filter_ref_deltas
;
913 ref_loop_filter_mode_deltas
=
914 priv
->ref
[current
->ref_frame_idx
[current
->primary_ref_frame
]].loop_filter_mode_deltas
;
917 flag(loop_filter_delta_update
);
918 for (i
= 0; i
< AV1_TOTAL_REFS_PER_FRAME
; i
++) {
919 if (current
->loop_filter_delta_update
)
920 flags(update_ref_delta
[i
], 1, i
);
922 infer(update_ref_delta
[i
], 0);
923 if (current
->update_ref_delta
[i
])
924 sus(1 + 6, loop_filter_ref_deltas
[i
], 1, i
);
926 infer(loop_filter_ref_deltas
[i
], ref_loop_filter_ref_deltas
[i
]);
928 for (i
= 0; i
< 2; i
++) {
929 if (current
->loop_filter_delta_update
)
930 flags(update_mode_delta
[i
], 1, i
);
932 infer(update_mode_delta
[i
], 0);
933 if (current
->update_mode_delta
[i
])
934 sus(1 + 6, loop_filter_mode_deltas
[i
], 1, i
);
936 infer(loop_filter_mode_deltas
[i
], ref_loop_filter_mode_deltas
[i
]);
939 for (i
= 0; i
< AV1_TOTAL_REFS_PER_FRAME
; i
++)
940 infer(loop_filter_ref_deltas
[i
], default_loop_filter_ref_deltas
[i
]);
941 for (i
= 0; i
< 2; i
++)
942 infer(loop_filter_mode_deltas
[i
], default_loop_filter_mode_deltas
[i
]);
948 static int FUNC(cdef_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
949 AV1RawFrameHeader
*current
)
951 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
952 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
955 if (priv
->coded_lossless
|| current
->allow_intrabc
||
957 infer(cdef_damping_minus_3
, 0);
959 infer(cdef_y_pri_strength
[0], 0);
960 infer(cdef_y_sec_strength
[0], 0);
961 infer(cdef_uv_pri_strength
[0], 0);
962 infer(cdef_uv_sec_strength
[0], 0);
967 fb(2, cdef_damping_minus_3
);
970 for (i
= 0; i
< (1 << current
->cdef_bits
); i
++) {
971 fbs(4, cdef_y_pri_strength
[i
], 1, i
);
972 fbs(2, cdef_y_sec_strength
[i
], 1, i
);
974 if (priv
->num_planes
> 1) {
975 fbs(4, cdef_uv_pri_strength
[i
], 1, i
);
976 fbs(2, cdef_uv_sec_strength
[i
], 1, i
);
983 static int FUNC(lr_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
984 AV1RawFrameHeader
*current
)
986 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
987 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
988 int uses_lr
, uses_chroma_lr
;
991 if (priv
->all_lossless
|| current
->allow_intrabc
||
992 !seq
->enable_restoration
) {
996 uses_lr
= uses_chroma_lr
= 0;
997 for (i
= 0; i
< priv
->num_planes
; i
++) {
998 fbs(2, lr_type
[i
], 1, i
);
1000 if (current
->lr_type
[i
] != AV1_RESTORE_NONE
) {
1008 if (seq
->use_128x128_superblock
)
1009 increment(lr_unit_shift
, 1, 2);
1011 increment(lr_unit_shift
, 0, 2);
1013 if(seq
->color_config
.subsampling_x
&&
1014 seq
->color_config
.subsampling_y
&& uses_chroma_lr
) {
1017 infer(lr_uv_shift
, 0);
1024 static int FUNC(read_tx_mode
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1025 AV1RawFrameHeader
*current
)
1027 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
1030 if (priv
->coded_lossless
)
1031 infer(tx_mode
, AV1_ONLY_4X4
);
1033 increment(tx_mode
, AV1_TX_MODE_LARGEST
, AV1_TX_MODE_SELECT
);
1038 static int FUNC(frame_reference_mode
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1039 AV1RawFrameHeader
*current
)
1043 if (current
->frame_type
== AV1_FRAME_INTRA_ONLY
||
1044 current
->frame_type
== AV1_FRAME_KEY
)
1045 infer(reference_select
, 0);
1047 flag(reference_select
);
1052 static int FUNC(skip_mode_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1053 AV1RawFrameHeader
*current
)
1055 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
1056 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
1057 int skip_mode_allowed
;
1060 if (current
->frame_type
== AV1_FRAME_KEY
||
1061 current
->frame_type
== AV1_FRAME_INTRA_ONLY
||
1062 !current
->reference_select
|| !seq
->enable_order_hint
) {
1063 skip_mode_allowed
= 0;
1065 int forward_idx
, backward_idx
;
1066 int forward_hint
, backward_hint
;
1067 int ref_hint
, dist
, i
;
1071 for (i
= 0; i
< AV1_REFS_PER_FRAME
; i
++) {
1072 ref_hint
= priv
->ref
[current
->ref_frame_idx
[i
]].order_hint
;
1073 dist
= cbs_av1_get_relative_dist(seq
, ref_hint
,
1076 if (forward_idx
< 0 ||
1077 cbs_av1_get_relative_dist(seq
, ref_hint
,
1078 forward_hint
) > 0) {
1080 forward_hint
= ref_hint
;
1082 } else if (dist
> 0) {
1083 if (backward_idx
< 0 ||
1084 cbs_av1_get_relative_dist(seq
, ref_hint
,
1085 backward_hint
) < 0) {
1087 backward_hint
= ref_hint
;
1092 if (forward_idx
< 0) {
1093 skip_mode_allowed
= 0;
1094 } else if (backward_idx
>= 0) {
1095 skip_mode_allowed
= 1;
1096 // Frames for skip mode are forward_idx and backward_idx.
1098 int second_forward_idx
;
1099 int second_forward_hint
;
1101 second_forward_idx
= -1;
1102 for (i
= 0; i
< AV1_REFS_PER_FRAME
; i
++) {
1103 ref_hint
= priv
->ref
[current
->ref_frame_idx
[i
]].order_hint
;
1104 if (cbs_av1_get_relative_dist(seq
, ref_hint
,
1105 forward_hint
) < 0) {
1106 if (second_forward_idx
< 0 ||
1107 cbs_av1_get_relative_dist(seq
, ref_hint
,
1108 second_forward_hint
) > 0) {
1109 second_forward_idx
= i
;
1110 second_forward_hint
= ref_hint
;
1115 if (second_forward_idx
< 0) {
1116 skip_mode_allowed
= 0;
1118 skip_mode_allowed
= 1;
1119 // Frames for skip mode are forward_idx and second_forward_idx.
1124 if (skip_mode_allowed
)
1125 flag(skip_mode_present
);
1127 infer(skip_mode_present
, 0);
1132 static int FUNC(global_motion_param
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1133 AV1RawFrameHeader
*current
,
1134 int type
, int ref
, int idx
)
1136 uint32_t abs_bits
, prec_bits
, num_syms
;
1140 if (type
== AV1_WARP_MODEL_TRANSLATION
) {
1141 abs_bits
= AV1_GM_ABS_TRANS_ONLY_BITS
- !current
->allow_high_precision_mv
;
1142 prec_bits
= AV1_GM_TRANS_ONLY_PREC_BITS
- !current
->allow_high_precision_mv
;
1144 abs_bits
= AV1_GM_ABS_TRANS_BITS
;
1145 prec_bits
= AV1_GM_TRANS_PREC_BITS
;
1148 abs_bits
= AV1_GM_ABS_ALPHA_BITS
;
1149 prec_bits
= AV1_GM_ALPHA_PREC_BITS
;
1152 num_syms
= 2 * (1 << abs_bits
) + 1;
1153 subexp(gm_params
[ref
][idx
], num_syms
, 2, ref
, idx
);
1155 // Actual gm_params value is not reconstructed here.
1161 static int FUNC(global_motion_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1162 AV1RawFrameHeader
*current
)
1167 if (current
->frame_type
== AV1_FRAME_KEY
||
1168 current
->frame_type
== AV1_FRAME_INTRA_ONLY
)
1171 for (ref
= AV1_REF_FRAME_LAST
; ref
<= AV1_REF_FRAME_ALTREF
; ref
++) {
1172 flags(is_global
[ref
], 1, ref
);
1173 if (current
->is_global
[ref
]) {
1174 flags(is_rot_zoom
[ref
], 1, ref
);
1175 if (current
->is_rot_zoom
[ref
]) {
1176 type
= AV1_WARP_MODEL_ROTZOOM
;
1178 flags(is_translation
[ref
], 1, ref
);
1179 type
= current
->is_translation
[ref
] ? AV1_WARP_MODEL_TRANSLATION
1180 : AV1_WARP_MODEL_AFFINE
;
1183 type
= AV1_WARP_MODEL_IDENTITY
;
1186 if (type
>= AV1_WARP_MODEL_ROTZOOM
) {
1187 CHECK(FUNC(global_motion_param
)(ctx
, rw
, current
, type
, ref
, 2));
1188 CHECK(FUNC(global_motion_param
)(ctx
, rw
, current
, type
, ref
, 3));
1189 if (type
== AV1_WARP_MODEL_AFFINE
) {
1190 CHECK(FUNC(global_motion_param
)(ctx
, rw
, current
, type
, ref
, 4));
1191 CHECK(FUNC(global_motion_param
)(ctx
, rw
, current
, type
, ref
, 5));
1193 // gm_params[ref][4] = -gm_params[ref][3]
1194 // gm_params[ref][5] = gm_params[ref][2]
1197 if (type
>= AV1_WARP_MODEL_TRANSLATION
) {
1198 CHECK(FUNC(global_motion_param
)(ctx
, rw
, current
, type
, ref
, 0));
1199 CHECK(FUNC(global_motion_param
)(ctx
, rw
, current
, type
, ref
, 1));
1206 static int FUNC(film_grain_params
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1207 AV1RawFilmGrainParams
*current
,
1208 AV1RawFrameHeader
*frame_header
)
1210 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
1211 const AV1RawSequenceHeader
*seq
= priv
->sequence_header
;
1212 int num_pos_luma
, num_pos_chroma
;
1215 if (!seq
->film_grain_params_present
||
1216 (!frame_header
->show_frame
&& !frame_header
->showable_frame
))
1221 if (!current
->apply_grain
)
1226 if (frame_header
->frame_type
== AV1_FRAME_INTER
)
1229 infer(update_grain
, 1);
1231 if (!current
->update_grain
) {
1232 fb(3, film_grain_params_ref_idx
);
1236 fc(4, num_y_points
, 0, 14);
1237 for (i
= 0; i
< current
->num_y_points
; i
++) {
1238 fcs(8, point_y_value
[i
],
1239 i
? current
->point_y_value
[i
- 1] + 1 : 0,
1240 MAX_UINT_BITS(8) - (current
->num_y_points
- i
- 1),
1242 fbs(8, point_y_scaling
[i
], 1, i
);
1245 if (seq
->color_config
.mono_chrome
)
1246 infer(chroma_scaling_from_luma
, 0);
1248 flag(chroma_scaling_from_luma
);
1250 if (seq
->color_config
.mono_chrome
||
1251 current
->chroma_scaling_from_luma
||
1252 (seq
->color_config
.subsampling_x
== 1 &&
1253 seq
->color_config
.subsampling_y
== 1 &&
1254 current
->num_y_points
== 0)) {
1255 infer(num_cb_points
, 0);
1256 infer(num_cr_points
, 0);
1258 fc(4, num_cb_points
, 0, 10);
1259 for (i
= 0; i
< current
->num_cb_points
; i
++) {
1260 fcs(8, point_cb_value
[i
],
1261 i
? current
->point_cb_value
[i
- 1] + 1 : 0,
1262 MAX_UINT_BITS(8) - (current
->num_cb_points
- i
- 1),
1264 fbs(8, point_cb_scaling
[i
], 1, i
);
1266 fc(4, num_cr_points
, 0, 10);
1267 for (i
= 0; i
< current
->num_cr_points
; i
++) {
1268 fcs(8, point_cr_value
[i
],
1269 i
? current
->point_cr_value
[i
- 1] + 1 : 0,
1270 MAX_UINT_BITS(8) - (current
->num_cr_points
- i
- 1),
1272 fbs(8, point_cr_scaling
[i
], 1, i
);
1276 fb(2, grain_scaling_minus_8
);
1277 fb(2, ar_coeff_lag
);
1278 num_pos_luma
= 2 * current
->ar_coeff_lag
* (current
->ar_coeff_lag
+ 1);
1279 if (current
->num_y_points
) {
1280 num_pos_chroma
= num_pos_luma
+ 1;
1281 for (i
= 0; i
< num_pos_luma
; i
++)
1282 fbs(8, ar_coeffs_y_plus_128
[i
], 1, i
);
1284 num_pos_chroma
= num_pos_luma
;
1286 if (current
->chroma_scaling_from_luma
|| current
->num_cb_points
) {
1287 for (i
= 0; i
< num_pos_chroma
; i
++)
1288 fbs(8, ar_coeffs_cb_plus_128
[i
], 1, i
);
1290 if (current
->chroma_scaling_from_luma
|| current
->num_cr_points
) {
1291 for (i
= 0; i
< num_pos_chroma
; i
++)
1292 fbs(8, ar_coeffs_cr_plus_128
[i
], 1, i
);
1294 fb(2, ar_coeff_shift_minus_6
);
1295 fb(2, grain_scale_shift
);
1296 if (current
->num_cb_points
) {
1298 fb(8, cb_luma_mult
);
1301 if (current
->num_cr_points
) {
1303 fb(8, cr_luma_mult
);
1308 flag(clip_to_restricted_range
);
1313 static int FUNC(uncompressed_header
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1314 AV1RawFrameHeader
*current
)
1316 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
1317 const AV1RawSequenceHeader
*seq
;
1318 int id_len
, diff_len
, all_frames
, frame_is_intra
, order_hint_bits
;
1321 if (!priv
->sequence_header
) {
1322 av_log(ctx
->log_ctx
, AV_LOG_ERROR
, "No sequence header available: "
1323 "unable to decode frame header.\n");
1324 return AVERROR_INVALIDDATA
;
1326 seq
= priv
->sequence_header
;
1328 id_len
= seq
->additional_frame_id_length_minus_1
+
1329 seq
->delta_frame_id_length_minus_2
+ 3;
1330 all_frames
= (1 << AV1_NUM_REF_FRAMES
) - 1;
1332 if (seq
->reduced_still_picture_header
) {
1333 infer(show_existing_frame
, 0);
1334 infer(frame_type
, AV1_FRAME_KEY
);
1335 infer(show_frame
, 1);
1336 infer(showable_frame
, 0);
1340 flag(show_existing_frame
);
1342 if (current
->show_existing_frame
) {
1343 AV1ReferenceFrameState
*ref
;
1345 fb(3, frame_to_show_map_idx
);
1346 ref
= &priv
->ref
[current
->frame_to_show_map_idx
];
1349 av_log(ctx
->log_ctx
, AV_LOG_ERROR
, "Missing reference frame needed for "
1350 "show_existing_frame (frame_to_show_map_idx = %d).\n",
1351 current
->frame_to_show_map_idx
);
1352 return AVERROR_INVALIDDATA
;
1355 if (seq
->decoder_model_info_present_flag
&&
1356 !seq
->timing_info
.equal_picture_interval
) {
1357 fb(seq
->decoder_model_info
.frame_presentation_time_length_minus_1
+ 1,
1358 frame_presentation_time
);
1361 if (seq
->frame_id_numbers_present_flag
)
1362 fb(id_len
, display_frame_id
);
1364 infer(frame_type
, ref
->frame_type
);
1365 if (current
->frame_type
== AV1_FRAME_KEY
) {
1366 infer(refresh_frame_flags
, all_frames
);
1369 infer(current_frame_id
, ref
->frame_id
);
1370 priv
->upscaled_width
= ref
->upscaled_width
;
1371 priv
->frame_width
= ref
->frame_width
;
1372 priv
->frame_height
= ref
->frame_height
;
1373 priv
->render_width
= ref
->render_width
;
1374 priv
->render_height
= ref
->render_height
;
1375 priv
->bit_depth
= ref
->bit_depth
;
1376 priv
->order_hint
= ref
->order_hint
;
1378 infer(refresh_frame_flags
, 0);
1380 infer(frame_width_minus_1
, ref
->upscaled_width
- 1);
1381 infer(frame_height_minus_1
, ref
->frame_height
- 1);
1382 infer(render_width_minus_1
, ref
->render_width
- 1);
1383 infer(render_height_minus_1
, ref
->render_height
- 1);
1390 frame_is_intra
= (current
->frame_type
== AV1_FRAME_INTRA_ONLY
||
1391 current
->frame_type
== AV1_FRAME_KEY
);
1394 if (current
->show_frame
&&
1395 seq
->decoder_model_info_present_flag
&&
1396 !seq
->timing_info
.equal_picture_interval
) {
1397 fb(seq
->decoder_model_info
.frame_presentation_time_length_minus_1
+ 1,
1398 frame_presentation_time
);
1400 if (current
->show_frame
)
1401 infer(showable_frame
, current
->frame_type
!= AV1_FRAME_KEY
);
1403 flag(showable_frame
);
1405 if (current
->frame_type
== AV1_FRAME_SWITCH
||
1406 (current
->frame_type
== AV1_FRAME_KEY
&& current
->show_frame
))
1407 infer(error_resilient_mode
, 1);
1409 flag(error_resilient_mode
);
1412 if (current
->frame_type
== AV1_FRAME_KEY
&& current
->show_frame
) {
1413 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++) {
1414 priv
->ref
[i
].valid
= 0;
1415 priv
->ref
[i
].order_hint
= 0;
1419 flag(disable_cdf_update
);
1421 if (seq
->seq_force_screen_content_tools
==
1422 AV1_SELECT_SCREEN_CONTENT_TOOLS
) {
1423 flag(allow_screen_content_tools
);
1425 infer(allow_screen_content_tools
,
1426 seq
->seq_force_screen_content_tools
);
1428 if (current
->allow_screen_content_tools
) {
1429 if (seq
->seq_force_integer_mv
== AV1_SELECT_INTEGER_MV
)
1430 flag(force_integer_mv
);
1432 infer(force_integer_mv
, seq
->seq_force_integer_mv
);
1434 infer(force_integer_mv
, 0);
1437 if (seq
->frame_id_numbers_present_flag
) {
1438 fb(id_len
, current_frame_id
);
1440 diff_len
= seq
->delta_frame_id_length_minus_2
+ 2;
1441 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++) {
1442 if (current
->current_frame_id
> (1 << diff_len
)) {
1443 if (priv
->ref
[i
].frame_id
> current
->current_frame_id
||
1444 priv
->ref
[i
].frame_id
< (current
->current_frame_id
-
1446 priv
->ref
[i
].valid
= 0;
1448 if (priv
->ref
[i
].frame_id
> current
->current_frame_id
&&
1449 priv
->ref
[i
].frame_id
< ((1 << id_len
) +
1450 current
->current_frame_id
-
1452 priv
->ref
[i
].valid
= 0;
1456 infer(current_frame_id
, 0);
1459 if (current
->frame_type
== AV1_FRAME_SWITCH
)
1460 infer(frame_size_override_flag
, 1);
1461 else if(seq
->reduced_still_picture_header
)
1462 infer(frame_size_override_flag
, 0);
1464 flag(frame_size_override_flag
);
1467 seq
->enable_order_hint
? seq
->order_hint_bits_minus_1
+ 1 : 0;
1468 if (order_hint_bits
> 0)
1469 fb(order_hint_bits
, order_hint
);
1471 infer(order_hint
, 0);
1472 priv
->order_hint
= current
->order_hint
;
1474 if (frame_is_intra
|| current
->error_resilient_mode
)
1475 infer(primary_ref_frame
, AV1_PRIMARY_REF_NONE
);
1477 fb(3, primary_ref_frame
);
1479 if (seq
->decoder_model_info_present_flag
) {
1480 flag(buffer_removal_time_present_flag
);
1481 if (current
->buffer_removal_time_present_flag
) {
1482 for (i
= 0; i
<= seq
->operating_points_cnt_minus_1
; i
++) {
1483 if (seq
->decoder_model_present_for_this_op
[i
]) {
1484 int op_pt_idc
= seq
->operating_point_idc
[i
];
1485 int in_temporal_layer
= (op_pt_idc
>> priv
->temporal_id
) & 1;
1486 int in_spatial_layer
= (op_pt_idc
>> (priv
->spatial_id
+ 8)) & 1;
1487 if (seq
->operating_point_idc
[i
] == 0 ||
1488 (in_temporal_layer
&& in_spatial_layer
)) {
1489 fbs(seq
->decoder_model_info
.buffer_removal_time_length_minus_1
+ 1,
1490 buffer_removal_time
[i
], 1, i
);
1497 if (current
->frame_type
== AV1_FRAME_SWITCH
||
1498 (current
->frame_type
== AV1_FRAME_KEY
&& current
->show_frame
))
1499 infer(refresh_frame_flags
, all_frames
);
1501 fb(8, refresh_frame_flags
);
1503 if (!frame_is_intra
|| current
->refresh_frame_flags
!= all_frames
) {
1504 if (seq
->enable_order_hint
) {
1505 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++) {
1506 if (current
->error_resilient_mode
)
1507 fbs(order_hint_bits
, ref_order_hint
[i
], 1, i
);
1509 infer(ref_order_hint
[i
], priv
->ref
[i
].order_hint
);
1510 if (current
->ref_order_hint
[i
] != priv
->ref
[i
].order_hint
)
1511 priv
->ref
[i
].valid
= 0;
1516 if (current
->frame_type
== AV1_FRAME_KEY
||
1517 current
->frame_type
== AV1_FRAME_INTRA_ONLY
) {
1518 CHECK(FUNC(frame_size
)(ctx
, rw
, current
));
1519 CHECK(FUNC(render_size
)(ctx
, rw
, current
));
1521 if (current
->allow_screen_content_tools
&&
1522 priv
->upscaled_width
== priv
->frame_width
)
1523 flag(allow_intrabc
);
1525 infer(allow_intrabc
, 0);
1528 if (!seq
->enable_order_hint
) {
1529 infer(frame_refs_short_signaling
, 0);
1531 flag(frame_refs_short_signaling
);
1532 if (current
->frame_refs_short_signaling
) {
1533 fb(3, last_frame_idx
);
1534 fb(3, golden_frame_idx
);
1535 CHECK(FUNC(set_frame_refs
)(ctx
, rw
, current
));
1539 for (i
= 0; i
< AV1_REFS_PER_FRAME
; i
++) {
1540 if (!current
->frame_refs_short_signaling
)
1541 fbs(3, ref_frame_idx
[i
], 1, i
);
1542 if (seq
->frame_id_numbers_present_flag
) {
1543 fbs(seq
->delta_frame_id_length_minus_2
+ 2,
1544 delta_frame_id_minus1
[i
], 1, i
);
1548 if (current
->frame_size_override_flag
&&
1549 !current
->error_resilient_mode
) {
1550 CHECK(FUNC(frame_size_with_refs
)(ctx
, rw
, current
));
1552 CHECK(FUNC(frame_size
)(ctx
, rw
, current
));
1553 CHECK(FUNC(render_size
)(ctx
, rw
, current
));
1556 if (current
->force_integer_mv
)
1557 infer(allow_high_precision_mv
, 0);
1559 flag(allow_high_precision_mv
);
1561 CHECK(FUNC(interpolation_filter
)(ctx
, rw
, current
));
1563 flag(is_motion_mode_switchable
);
1565 if (current
->error_resilient_mode
||
1566 !seq
->enable_ref_frame_mvs
)
1567 infer(use_ref_frame_mvs
, 0);
1569 flag(use_ref_frame_mvs
);
1571 infer(allow_intrabc
, 0);
1574 if (!frame_is_intra
) {
1575 // Derive reference frame sign biases.
1578 if (seq
->reduced_still_picture_header
|| current
->disable_cdf_update
)
1579 infer(disable_frame_end_update_cdf
, 1);
1581 flag(disable_frame_end_update_cdf
);
1583 if (current
->primary_ref_frame
== AV1_PRIMARY_REF_NONE
) {
1584 // Init non-coeff CDFs.
1585 // Setup past independence.
1587 // Load CDF tables from previous frame.
1588 // Load params from previous frame.
1591 if (current
->use_ref_frame_mvs
) {
1592 // Perform motion field estimation process.
1595 CHECK(FUNC(tile_info
)(ctx
, rw
, current
));
1597 CHECK(FUNC(quantization_params
)(ctx
, rw
, current
));
1599 CHECK(FUNC(segmentation_params
)(ctx
, rw
, current
));
1601 CHECK(FUNC(delta_q_params
)(ctx
, rw
, current
));
1603 CHECK(FUNC(delta_lf_params
)(ctx
, rw
, current
));
1605 // Init coeff CDFs / load previous segments.
1607 priv
->coded_lossless
= 1;
1608 for (i
= 0; i
< AV1_MAX_SEGMENTS
; i
++) {
1610 if (current
->feature_enabled
[i
][AV1_SEG_LVL_ALT_Q
]) {
1611 qindex
= (current
->base_q_idx
+
1612 current
->feature_value
[i
][AV1_SEG_LVL_ALT_Q
]);
1614 qindex
= current
->base_q_idx
;
1616 qindex
= av_clip_uintp2(qindex
, 8);
1618 if (qindex
|| current
->delta_q_y_dc
||
1619 current
->delta_q_u_ac
|| current
->delta_q_u_dc
||
1620 current
->delta_q_v_ac
|| current
->delta_q_v_dc
) {
1621 priv
->coded_lossless
= 0;
1624 priv
->all_lossless
= priv
->coded_lossless
&&
1625 priv
->frame_width
== priv
->upscaled_width
;
1627 CHECK(FUNC(loop_filter_params
)(ctx
, rw
, current
));
1629 CHECK(FUNC(cdef_params
)(ctx
, rw
, current
));
1631 CHECK(FUNC(lr_params
)(ctx
, rw
, current
));
1633 CHECK(FUNC(read_tx_mode
)(ctx
, rw
, current
));
1635 CHECK(FUNC(frame_reference_mode
)(ctx
, rw
, current
));
1637 CHECK(FUNC(skip_mode_params
)(ctx
, rw
, current
));
1639 if (frame_is_intra
|| current
->error_resilient_mode
||
1640 !seq
->enable_warped_motion
)
1641 infer(allow_warped_motion
, 0);
1643 flag(allow_warped_motion
);
1645 flag(reduced_tx_set
);
1647 CHECK(FUNC(global_motion_params
)(ctx
, rw
, current
));
1649 CHECK(FUNC(film_grain_params
)(ctx
, rw
, ¤t
->film_grain
, current
));
1651 av_log(ctx
->log_ctx
, AV_LOG_DEBUG
, "Frame %d: size %dx%d "
1652 "upscaled %d render %dx%d subsample %dx%d "
1653 "bitdepth %d tiles %dx%d.\n", priv
->order_hint
,
1654 priv
->frame_width
, priv
->frame_height
, priv
->upscaled_width
,
1655 priv
->render_width
, priv
->render_height
,
1656 seq
->color_config
.subsampling_x
+ 1,
1657 seq
->color_config
.subsampling_y
+ 1, priv
->bit_depth
,
1658 priv
->tile_rows
, priv
->tile_cols
);
1661 for (i
= 0; i
< AV1_NUM_REF_FRAMES
; i
++) {
1662 if (current
->refresh_frame_flags
& (1 << i
)) {
1663 priv
->ref
[i
] = (AV1ReferenceFrameState
) {
1665 .frame_id
= current
->current_frame_id
,
1666 .upscaled_width
= priv
->upscaled_width
,
1667 .frame_width
= priv
->frame_width
,
1668 .frame_height
= priv
->frame_height
,
1669 .render_width
= priv
->render_width
,
1670 .render_height
= priv
->render_height
,
1671 .frame_type
= current
->frame_type
,
1672 .subsampling_x
= seq
->color_config
.subsampling_x
,
1673 .subsampling_y
= seq
->color_config
.subsampling_y
,
1674 .bit_depth
= priv
->bit_depth
,
1675 .order_hint
= priv
->order_hint
,
1677 memcpy(priv
->ref
[i
].loop_filter_ref_deltas
, current
->loop_filter_ref_deltas
,
1678 sizeof(current
->loop_filter_ref_deltas
));
1679 memcpy(priv
->ref
[i
].loop_filter_mode_deltas
, current
->loop_filter_mode_deltas
,
1680 sizeof(current
->loop_filter_mode_deltas
));
1681 memcpy(priv
->ref
[i
].feature_enabled
, current
->feature_enabled
,
1682 sizeof(current
->feature_enabled
));
1683 memcpy(priv
->ref
[i
].feature_value
, current
->feature_value
,
1684 sizeof(current
->feature_value
));
1691 static int FUNC(frame_header_obu
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1692 AV1RawFrameHeader
*current
, int redundant
,
1693 AVBufferRef
*rw_buffer_ref
)
1695 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
1696 int start_pos
, fh_bits
, fh_bytes
, err
;
1699 if (priv
->seen_frame_header
) {
1701 av_log(ctx
->log_ctx
, AV_LOG_ERROR
, "Invalid repeated "
1702 "frame header OBU.\n");
1703 return AVERROR_INVALIDDATA
;
1709 HEADER("Redundant Frame Header");
1711 av_assert0(priv
->frame_header_ref
&& priv
->frame_header
);
1713 init_get_bits(&fh
, priv
->frame_header
,
1714 priv
->frame_header_size
);
1715 for (i
= 0; i
< priv
->frame_header_size
; i
+= 8) {
1716 b
= FFMIN(priv
->frame_header_size
- i
, 8);
1717 val
= get_bits(&fh
, b
);
1718 xf(b
, frame_header_copy
[i
],
1719 val
, val
, val
, 1, i
/ 8);
1724 HEADER("Redundant Frame Header (used as Frame Header)");
1726 HEADER("Frame Header");
1729 start_pos
= get_bits_count(rw
);
1731 start_pos
= put_bits_count(rw
);
1734 CHECK(FUNC(uncompressed_header
)(ctx
, rw
, current
));
1738 if (current
->show_existing_frame
) {
1739 priv
->seen_frame_header
= 0;
1741 priv
->seen_frame_header
= 1;
1743 av_buffer_unref(&priv
->frame_header_ref
);
1746 fh_bits
= get_bits_count(rw
) - start_pos
;
1747 fh_start
= (uint8_t*)rw
->buffer
+ start_pos
/ 8;
1749 // Need to flush the bitwriter so that we can copy its output,
1750 // but use a copy so we don't affect the caller's structure.
1752 PutBitContext tmp
= *rw
;
1753 flush_put_bits(&tmp
);
1756 fh_bits
= put_bits_count(rw
) - start_pos
;
1757 fh_start
= rw
->buf
+ start_pos
/ 8;
1759 fh_bytes
= (fh_bits
+ 7) / 8;
1761 priv
->frame_header_size
= fh_bits
;
1763 if (rw_buffer_ref
) {
1764 priv
->frame_header_ref
= av_buffer_ref(rw_buffer_ref
);
1765 if (!priv
->frame_header_ref
)
1766 return AVERROR(ENOMEM
);
1767 priv
->frame_header
= fh_start
;
1769 priv
->frame_header_ref
=
1770 av_buffer_alloc(fh_bytes
+ AV_INPUT_BUFFER_PADDING_SIZE
);
1771 if (!priv
->frame_header_ref
)
1772 return AVERROR(ENOMEM
);
1773 priv
->frame_header
= priv
->frame_header_ref
->data
;
1774 memcpy(priv
->frame_header
, fh_start
, fh_bytes
);
1782 static int FUNC(tile_group_obu
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1783 AV1RawTileGroup
*current
)
1785 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
1786 int num_tiles
, tile_bits
;
1789 HEADER("Tile Group");
1791 num_tiles
= priv
->tile_cols
* priv
->tile_rows
;
1793 flag(tile_start_and_end_present_flag
);
1795 infer(tile_start_and_end_present_flag
, 0);
1797 if (num_tiles
== 1 || !current
->tile_start_and_end_present_flag
) {
1799 infer(tg_end
, num_tiles
- 1);
1801 tile_bits
= cbs_av1_tile_log2(1, priv
->tile_cols
) +
1802 cbs_av1_tile_log2(1, priv
->tile_rows
);
1803 fc(tile_bits
, tg_start
, priv
->tile_num
, num_tiles
- 1);
1804 fc(tile_bits
, tg_end
, current
->tg_start
, num_tiles
- 1);
1807 priv
->tile_num
= current
->tg_end
+ 1;
1809 CHECK(FUNC(byte_alignment
)(ctx
, rw
));
1811 // Reset header for next frame.
1812 if (current
->tg_end
== num_tiles
- 1)
1813 priv
->seen_frame_header
= 0;
1815 // Tile data follows.
1820 static int FUNC(frame_obu
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1821 AV1RawFrame
*current
,
1822 AVBufferRef
*rw_buffer_ref
)
1826 CHECK(FUNC(frame_header_obu
)(ctx
, rw
, ¤t
->header
,
1829 CHECK(FUNC(byte_alignment
)(ctx
, rw
));
1831 CHECK(FUNC(tile_group_obu
)(ctx
, rw
, ¤t
->tile_group
));
1836 static int FUNC(tile_list_obu
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1837 AV1RawTileList
*current
)
1841 fb(8, output_frame_width_in_tiles_minus_1
);
1842 fb(8, output_frame_height_in_tiles_minus_1
);
1844 fb(16, tile_count_minus_1
);
1846 // Tile data follows.
1851 static int FUNC(metadata_hdr_cll
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1852 AV1RawMetadataHDRCLL
*current
)
1856 HEADER("HDR CLL Metadata");
1864 static int FUNC(metadata_hdr_mdcv
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1865 AV1RawMetadataHDRMDCV
*current
)
1869 HEADER("HDR MDCV Metadata");
1871 for (i
= 0; i
< 3; i
++) {
1872 fbs(16, primary_chromaticity_x
[i
], 1, i
);
1873 fbs(16, primary_chromaticity_y
[i
], 1, i
);
1876 fb(16, white_point_chromaticity_x
);
1877 fb(16, white_point_chromaticity_y
);
1879 fb(32, luminance_max
);
1880 fb(32, luminance_min
);
1885 static int FUNC(scalability_structure
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1886 AV1RawMetadataScalability
*current
)
1888 CodedBitstreamAV1Context
*priv
= ctx
->priv_data
;
1889 const AV1RawSequenceHeader
*seq
;
1892 if (!priv
->sequence_header
) {
1893 av_log(ctx
->log_ctx
, AV_LOG_ERROR
, "No sequence header available: "
1894 "unable to parse scalability metadata.\n");
1895 return AVERROR_INVALIDDATA
;
1897 seq
= priv
->sequence_header
;
1899 fb(2, spatial_layers_cnt_minus_1
);
1900 flag(spatial_layer_dimensions_present_flag
);
1901 flag(spatial_layer_description_present_flag
);
1902 flag(temporal_group_description_present_flag
);
1903 fc(3, scalability_structure_reserved_3bits
, 0, 0);
1904 if (current
->spatial_layer_dimensions_present_flag
) {
1905 for (i
= 0; i
<= current
->spatial_layers_cnt_minus_1
; i
++) {
1906 fcs(16, spatial_layer_max_width
[i
],
1907 0, seq
->max_frame_width_minus_1
+ 1, 1, i
);
1908 fcs(16, spatial_layer_max_height
[i
],
1909 0, seq
->max_frame_height_minus_1
+ 1, 1, i
);
1912 if (current
->spatial_layer_description_present_flag
) {
1913 for (i
= 0; i
<= current
->spatial_layers_cnt_minus_1
; i
++)
1914 fbs(8, spatial_layer_ref_id
[i
], 1, i
);
1916 if (current
->temporal_group_description_present_flag
) {
1917 fb(8, temporal_group_size
);
1918 for (i
= 0; i
< current
->temporal_group_size
; i
++) {
1919 fbs(3, temporal_group_temporal_id
[i
], 1, i
);
1920 flags(temporal_group_temporal_switching_up_point_flag
[i
], 1, i
);
1921 flags(temporal_group_spatial_switching_up_point_flag
[i
], 1, i
);
1922 fbs(3, temporal_group_ref_cnt
[i
], 1, i
);
1923 for (j
= 0; j
< current
->temporal_group_ref_cnt
[i
]; j
++) {
1924 fbs(8, temporal_group_ref_pic_diff
[i
][j
], 2, i
, j
);
1932 static int FUNC(metadata_scalability
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1933 AV1RawMetadataScalability
*current
)
1937 HEADER("Scalability Metadata");
1939 fb(8, scalability_mode_idc
);
1941 if (current
->scalability_mode_idc
== AV1_SCALABILITY_SS
)
1942 CHECK(FUNC(scalability_structure
)(ctx
, rw
, current
));
1947 static int FUNC(metadata_itut_t35
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1948 AV1RawMetadataITUTT35
*current
)
1953 HEADER("ITU-T T.35 Metadata");
1955 fb(8, itu_t_t35_country_code
);
1956 if (current
->itu_t_t35_country_code
== 0xff)
1957 fb(8, itu_t_t35_country_code_extension_byte
);
1960 // The payload runs up to the start of the trailing bits, but there might
1961 // be arbitrarily many trailing zeroes so we need to read through twice.
1962 current
->payload_size
= cbs_av1_get_payload_bytes_left(rw
);
1964 current
->payload_ref
= av_buffer_alloc(current
->payload_size
);
1965 if (!current
->payload_ref
)
1966 return AVERROR(ENOMEM
);
1967 current
->payload
= current
->payload_ref
->data
;
1970 for (i
= 0; i
< current
->payload_size
; i
++)
1971 xf(8, itu_t_t35_payload_bytes
[i
], current
->payload
[i
],
1977 static int FUNC(metadata_timecode
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
1978 AV1RawMetadataTimecode
*current
)
1982 HEADER("Timecode Metadata");
1984 fb(5, counting_type
);
1985 flag(full_timestamp_flag
);
1986 flag(discontinuity_flag
);
1987 flag(cnt_dropped_flag
);
1990 if (current
->full_timestamp_flag
) {
1991 fc(6, seconds_value
, 0, 59);
1992 fc(6, minutes_value
, 0, 59);
1993 fc(5, hours_value
, 0, 23);
1996 if (current
->seconds_flag
) {
1997 fc(6, seconds_value
, 0, 59);
1999 if (current
->minutes_flag
) {
2000 fc(6, minutes_value
, 0, 59);
2002 if (current
->hours_flag
)
2003 fc(5, hours_value
, 0, 23);
2008 fb(5, time_offset_length
);
2009 if (current
->time_offset_length
> 0)
2010 fb(current
->time_offset_length
, time_offset_value
);
2012 infer(time_offset_length
, 0);
2017 static int FUNC(metadata_unknown
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
2018 AV1RawMetadataUnknown
*current
)
2023 HEADER("Unknown Metadata");
2026 current
->payload_size
= cbs_av1_get_payload_bytes_left(rw
);
2028 current
->payload_ref
= av_buffer_alloc(current
->payload_size
);
2029 if (!current
->payload_ref
)
2030 return AVERROR(ENOMEM
);
2031 current
->payload
= current
->payload_ref
->data
;
2034 for (i
= 0; i
< current
->payload_size
; i
++)
2035 fbs(8, payload
[i
], 1, i
);
2040 static int FUNC(metadata_obu
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
2041 AV1RawMetadata
*current
)
2045 leb128(metadata_type
);
2047 switch (current
->metadata_type
) {
2048 case AV1_METADATA_TYPE_HDR_CLL
:
2049 CHECK(FUNC(metadata_hdr_cll
)(ctx
, rw
, ¤t
->metadata
.hdr_cll
));
2051 case AV1_METADATA_TYPE_HDR_MDCV
:
2052 CHECK(FUNC(metadata_hdr_mdcv
)(ctx
, rw
, ¤t
->metadata
.hdr_mdcv
));
2054 case AV1_METADATA_TYPE_SCALABILITY
:
2055 CHECK(FUNC(metadata_scalability
)(ctx
, rw
, ¤t
->metadata
.scalability
));
2057 case AV1_METADATA_TYPE_ITUT_T35
:
2058 CHECK(FUNC(metadata_itut_t35
)(ctx
, rw
, ¤t
->metadata
.itut_t35
));
2060 case AV1_METADATA_TYPE_TIMECODE
:
2061 CHECK(FUNC(metadata_timecode
)(ctx
, rw
, ¤t
->metadata
.timecode
));
2064 CHECK(FUNC(metadata_unknown
)(ctx
, rw
, ¤t
->metadata
.unknown
));
2070 static int FUNC(padding_obu
)(CodedBitstreamContext
*ctx
, RWContext
*rw
,
2071 AV1RawPadding
*current
)
2078 // The payload runs up to the start of the trailing bits, but there might
2079 // be arbitrarily many trailing zeroes so we need to read through twice.
2080 current
->payload_size
= cbs_av1_get_payload_bytes_left(rw
);
2082 current
->payload_ref
= av_buffer_alloc(current
->payload_size
);
2083 if (!current
->payload_ref
)
2084 return AVERROR(ENOMEM
);
2085 current
->payload
= current
->payload_ref
->data
;
2088 for (i
= 0; i
< current
->payload_size
; i
++)
2089 xf(8, obu_padding_byte
[i
], current
->payload
[i
], 0x00, 0xff, 1, i
);