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(frame_sync_code)(CodedBitstreamContext *ctx, RWContext *rw,
20 VP9RawFrameHeader *current)
22 uint8_t frame_sync_byte_0 = VP9_FRAME_SYNC_0;
23 uint8_t frame_sync_byte_1 = VP9_FRAME_SYNC_1;
24 uint8_t frame_sync_byte_2 = VP9_FRAME_SYNC_2;
27 xf(8, frame_sync_byte_0, frame_sync_byte_0, 0);
28 xf(8, frame_sync_byte_1, frame_sync_byte_1, 0);
29 xf(8, frame_sync_byte_2, frame_sync_byte_2, 0);
31 if (frame_sync_byte_0 != VP9_FRAME_SYNC_0 ||
32 frame_sync_byte_1 != VP9_FRAME_SYNC_1 ||
33 frame_sync_byte_2 != VP9_FRAME_SYNC_2) {
34 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid frame sync code: "
35 "%02x %02x %02x.\n", frame_sync_byte_0,
36 frame_sync_byte_1, frame_sync_byte_2);
37 return AVERROR_INVALIDDATA;
43 static int FUNC(color_config)(CodedBitstreamContext *ctx, RWContext *rw,
44 VP9RawFrameHeader *current, int profile)
46 CodedBitstreamVP9Context *vp9 = ctx->priv_data;
50 f(1, ten_or_twelve_bit);
51 vp9->bit_depth = current->ten_or_twelve_bit ? 12 : 10;
57 if (current->color_space != VP9_CS_RGB) {
59 if (profile == 1 || profile == 3) {
62 fixed(1, reserved_zero, 0);
64 infer(subsampling_x, 1);
65 infer(subsampling_y, 1);
68 infer(color_range, 1);
69 if (profile == 1 || profile == 3) {
70 infer(subsampling_x, 0);
71 infer(subsampling_y, 0);
72 fixed(1, reserved_zero, 0);
76 vp9->subsampling_x = current->subsampling_x;
77 vp9->subsampling_y = current->subsampling_y;
82 static int FUNC(frame_size)(CodedBitstreamContext *ctx, RWContext *rw,
83 VP9RawFrameHeader *current)
85 CodedBitstreamVP9Context *vp9 = ctx->priv_data;
88 f(16, frame_width_minus_1);
89 f(16, frame_height_minus_1);
91 vp9->frame_width = current->frame_width_minus_1 + 1;
92 vp9->frame_height = current->frame_height_minus_1 + 1;
94 vp9->mi_cols = (vp9->frame_width + 7) >> 3;
95 vp9->mi_rows = (vp9->frame_height + 7) >> 3;
96 vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
97 vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;
102 static int FUNC(render_size)(CodedBitstreamContext *ctx, RWContext *rw,
103 VP9RawFrameHeader *current)
107 f(1, render_and_frame_size_different);
109 if (current->render_and_frame_size_different) {
110 f(16, render_width_minus_1);
111 f(16, render_height_minus_1);
117 static int FUNC(frame_size_with_refs)(CodedBitstreamContext *ctx, RWContext *rw,
118 VP9RawFrameHeader *current)
120 CodedBitstreamVP9Context *vp9 = ctx->priv_data;
123 for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
124 fs(1, found_ref[i], 1, i);
125 if (current->found_ref[i]) {
126 VP9ReferenceFrameState *ref =
127 &vp9->ref[current->ref_frame_idx[i]];
129 vp9->frame_width = ref->frame_width;
130 vp9->frame_height = ref->frame_height;
132 vp9->subsampling_x = ref->subsampling_x;
133 vp9->subsampling_y = ref->subsampling_y;
134 vp9->bit_depth = ref->bit_depth;
139 if (i >= VP9_REFS_PER_FRAME)
140 CHECK(FUNC(frame_size)(ctx, rw, current));
142 vp9->mi_cols = (vp9->frame_width + 7) >> 3;
143 vp9->mi_rows = (vp9->frame_height + 7) >> 3;
144 vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
145 vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;
147 CHECK(FUNC(render_size)(ctx, rw, current));
152 static int FUNC(interpolation_filter)(CodedBitstreamContext *ctx, RWContext *rw,
153 VP9RawFrameHeader *current)
157 f(1, is_filter_switchable);
158 if (!current->is_filter_switchable)
159 f(2, raw_interpolation_filter_type);
164 static int FUNC(loop_filter_params)(CodedBitstreamContext *ctx, RWContext *rw,
165 VP9RawFrameHeader *current)
169 f(6, loop_filter_level);
170 f(3, loop_filter_sharpness);
172 f(1, loop_filter_delta_enabled);
173 if (current->loop_filter_delta_enabled) {
174 f(1, loop_filter_delta_update);
175 if (current->loop_filter_delta_update) {
176 for (i = 0; i < VP9_MAX_REF_FRAMES; i++) {
177 fs(1, update_ref_delta[i], 1, i);
178 if (current->update_ref_delta[i])
179 ss(6, loop_filter_ref_deltas[i], 1, i);
181 for (i = 0; i < 2; i++) {
182 fs(1, update_mode_delta[i], 1, i);
183 if (current->update_mode_delta[i])
184 ss(6, loop_filter_mode_deltas[i], 1, i);
192 static int FUNC(quantization_params)(CodedBitstreamContext *ctx, RWContext *rw,
193 VP9RawFrameHeader *current)
199 delta_q(delta_q_y_dc);
200 delta_q(delta_q_uv_dc);
201 delta_q(delta_q_uv_ac);
206 static int FUNC(segmentation_params)(CodedBitstreamContext *ctx, RWContext *rw,
207 VP9RawFrameHeader *current)
209 static const uint8_t segmentation_feature_bits[VP9_SEG_LVL_MAX] = { 8, 6, 2, 0 };
210 static const uint8_t segmentation_feature_signed[VP9_SEG_LVL_MAX] = { 1, 1, 0, 0 };
214 f(1, segmentation_enabled);
216 if (current->segmentation_enabled) {
217 f(1, segmentation_update_map);
218 if (current->segmentation_update_map) {
219 for (i = 0; i < 7; i++)
220 prob(segmentation_tree_probs[i], 1, i);
221 f(1, segmentation_temporal_update);
222 for (i = 0; i < 3; i++) {
223 if (current->segmentation_temporal_update)
224 prob(segmentation_pred_prob[i], 1, i);
226 infer(segmentation_pred_prob[i], 255);
230 f(1, segmentation_update_data);
231 if (current->segmentation_update_data) {
232 f(1, segmentation_abs_or_delta_update);
233 for (i = 0; i < VP9_MAX_SEGMENTS; i++) {
234 for (j = 0; j < VP9_SEG_LVL_MAX; j++) {
235 fs(1, feature_enabled[i][j], 2, i, j);
236 if (current->feature_enabled[i][j] &&
237 segmentation_feature_bits[j]) {
238 fs(segmentation_feature_bits[j],
239 feature_value[i][j], 2, i, j);
240 if (segmentation_feature_signed[j])
241 fs(1, feature_sign[i][j], 2, i, j);
243 infer(feature_sign[i][j], 0);
245 infer(feature_value[i][j], 0);
246 infer(feature_sign[i][j], 0);
256 static int FUNC(tile_info)(CodedBitstreamContext *ctx, RWContext *rw,
257 VP9RawFrameHeader *current)
259 CodedBitstreamVP9Context *vp9 = ctx->priv_data;
260 int min_log2_tile_cols, max_log2_tile_cols;
263 min_log2_tile_cols = 0;
264 while ((VP9_MAX_TILE_WIDTH_B64 << min_log2_tile_cols) < vp9->sb64_cols)
265 ++min_log2_tile_cols;
266 max_log2_tile_cols = 0;
267 while ((vp9->sb64_cols >> (max_log2_tile_cols + 1)) >= VP9_MIN_TILE_WIDTH_B64)
268 ++max_log2_tile_cols;
270 increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);
272 increment(tile_rows_log2, 0, 2);
277 static int FUNC(uncompressed_header)(CodedBitstreamContext *ctx, RWContext *rw,
278 VP9RawFrameHeader *current)
280 CodedBitstreamVP9Context *vp9 = ctx->priv_data;
285 f(1, profile_low_bit);
286 f(1, profile_high_bit);
287 vp9->profile = (current->profile_high_bit << 1) + current->profile_low_bit;
288 if (vp9->profile == 3)
289 fixed(1, reserved_zero, 0);
291 f(1, show_existing_frame);
292 if (current->show_existing_frame) {
293 f(3, frame_to_show_map_idx);
294 infer(header_size_in_bytes, 0);
295 infer(refresh_frame_flags, 0x00);
296 infer(loop_filter_level, 0);
302 f(1, error_resilient_mode);
304 if (current->frame_type == VP9_KEY_FRAME) {
305 CHECK(FUNC(frame_sync_code)(ctx, rw, current));
306 CHECK(FUNC(color_config)(ctx, rw, current, vp9->profile));
307 CHECK(FUNC(frame_size)(ctx, rw, current));
308 CHECK(FUNC(render_size)(ctx, rw, current));
310 infer(refresh_frame_flags, 0xff);
313 if (current->show_frame == 0)
316 infer(intra_only, 0);
318 if (current->error_resilient_mode == 0)
319 f(2, reset_frame_context);
321 infer(reset_frame_context, 0);
323 if (current->intra_only == 1) {
324 CHECK(FUNC(frame_sync_code)(ctx, rw, current));
326 if (vp9->profile > 0) {
327 CHECK(FUNC(color_config)(ctx, rw, current, vp9->profile));
329 infer(color_space, 1);
330 infer(subsampling_x, 1);
331 infer(subsampling_y, 1);
334 vp9->subsampling_x = current->subsampling_x;
335 vp9->subsampling_y = current->subsampling_y;
338 f(8, refresh_frame_flags);
340 CHECK(FUNC(frame_size)(ctx, rw, current));
341 CHECK(FUNC(render_size)(ctx, rw, current));
343 f(8, refresh_frame_flags);
345 for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
346 fs(3, ref_frame_idx[i], 1, i);
347 fs(1, ref_frame_sign_bias[VP9_LAST_FRAME + i],
348 1, VP9_LAST_FRAME + i);
351 CHECK(FUNC(frame_size_with_refs)(ctx, rw, current));
352 f(1, allow_high_precision_mv);
353 CHECK(FUNC(interpolation_filter)(ctx, rw, current));
357 if (current->error_resilient_mode == 0) {
358 f(1, refresh_frame_context);
359 f(1, frame_parallel_decoding_mode);
361 infer(refresh_frame_context, 0);
362 infer(frame_parallel_decoding_mode, 1);
365 f(2, frame_context_idx);
367 CHECK(FUNC(loop_filter_params)(ctx, rw, current));
368 CHECK(FUNC(quantization_params)(ctx, rw, current));
369 CHECK(FUNC(segmentation_params)(ctx, rw, current));
370 CHECK(FUNC(tile_info)(ctx, rw, current));
372 f(16, header_size_in_bytes);
374 for (i = 0; i < VP9_NUM_REF_FRAMES; i++) {
375 if (current->refresh_frame_flags & (1 << i)) {
376 vp9->ref[i] = (VP9ReferenceFrameState) {
377 .frame_width = vp9->frame_width,
378 .frame_height = vp9->frame_height,
379 .subsampling_x = vp9->subsampling_x,
380 .subsampling_y = vp9->subsampling_y,
381 .bit_depth = vp9->bit_depth,
386 av_log(ctx->log_ctx, AV_LOG_DEBUG, "Frame: size %dx%d "
387 "subsample %dx%d bit_depth %d tiles %dx%d.\n",
388 vp9->frame_width, vp9->frame_height,
389 vp9->subsampling_x, vp9->subsampling_y,
390 vp9->bit_depth, 1 << current->tile_cols_log2,
391 1 << current->tile_rows_log2);
396 static int FUNC(trailing_bits)(CodedBitstreamContext *ctx, RWContext *rw)
399 av_unused int zero = 0;
400 while (byte_alignment(rw) != 0)
401 xf(1, zero_bit, zero, 0);
406 static int FUNC(frame)(CodedBitstreamContext *ctx, RWContext *rw,
407 VP9RawFrame *current)
413 CHECK(FUNC(uncompressed_header)(ctx, rw, ¤t->header));
415 CHECK(FUNC(trailing_bits)(ctx, rw));
420 static int FUNC(superframe_index)(CodedBitstreamContext *ctx, RWContext *rw,
421 VP9RawSuperframeIndex *current)
425 HEADER("Superframe Index");
427 f(3, superframe_marker);
428 f(2, bytes_per_framesize_minus_1);
429 f(3, frames_in_superframe_minus_1);
431 for (i = 0; i <= current->frames_in_superframe_minus_1; i++) {
432 // Surprise little-endian!
433 fle(8 * (current->bytes_per_framesize_minus_1 + 1),
434 frame_sizes[i], 1, i);
437 f(3, superframe_marker);
438 f(2, bytes_per_framesize_minus_1);
439 f(3, frames_in_superframe_minus_1);