FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/cbs_vp9_syntax_template.c	Lines:	210	233	90.1 %
Date:	2020-04-02 05:41:20	Branches:	178	314	56.7 %


/*
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

static int FUNC(frame_sync_code)(CodedBitstreamContext *ctx, RWContext *rw,
                                 VP9RawFrameHeader *current)
{
    uint8_t frame_sync_byte_0 = VP9_FRAME_SYNC_0;
    uint8_t frame_sync_byte_1 = VP9_FRAME_SYNC_1;
    uint8_t frame_sync_byte_2 = VP9_FRAME_SYNC_2;
    int err;

    xf(8, frame_sync_byte_0, frame_sync_byte_0, 0);
    xf(8, frame_sync_byte_1, frame_sync_byte_1, 0);
    xf(8, frame_sync_byte_2, frame_sync_byte_2, 0);

    if (frame_sync_byte_0 != VP9_FRAME_SYNC_0 ||
        frame_sync_byte_1 != VP9_FRAME_SYNC_1 ||
        frame_sync_byte_2 != VP9_FRAME_SYNC_2) {
        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid frame sync code: "
               "%02x %02x %02x.\n", frame_sync_byte_0,
               frame_sync_byte_1, frame_sync_byte_2);
        return AVERROR_INVALIDDATA;
    }

    return 0;
}

static int FUNC(color_config)(CodedBitstreamContext *ctx, RWContext *rw,
                              VP9RawFrameHeader *current, int profile)
{
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
    int err;

    if (profile >= 2) {
        f(1, ten_or_twelve_bit);
        vp9->bit_depth = current->ten_or_twelve_bit ? 12 : 10;
    } else
        vp9->bit_depth = 8;

    f(3, color_space);

    if (current->color_space != VP9_CS_RGB) {
        f(1, color_range);
        if (profile == 1 || profile == 3) {
            f(1, subsampling_x);
            f(1, subsampling_y);
            fixed(1, reserved_zero, 0);
        } else {
            infer(subsampling_x, 1);
            infer(subsampling_y, 1);
        }
    } else {
        infer(color_range, 1);
        if (profile == 1 || profile == 3) {
            infer(subsampling_x, 0);
            infer(subsampling_y, 0);
            fixed(1, reserved_zero, 0);
        }
    }

    vp9->subsampling_x = current->subsampling_x;
    vp9->subsampling_y = current->subsampling_y;

    return 0;
}

static int FUNC(frame_size)(CodedBitstreamContext *ctx, RWContext *rw,
                            VP9RawFrameHeader *current)
{
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
    int err;

    f(16, frame_width_minus_1);
    f(16, frame_height_minus_1);

    vp9->frame_width  = current->frame_width_minus_1  + 1;
    vp9->frame_height = current->frame_height_minus_1 + 1;

    vp9->mi_cols = (vp9->frame_width  + 7) >> 3;
    vp9->mi_rows = (vp9->frame_height + 7) >> 3;
    vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
    vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;

    return 0;
}

static int FUNC(render_size)(CodedBitstreamContext *ctx, RWContext *rw,
                             VP9RawFrameHeader *current)
{
    int err;

    f(1, render_and_frame_size_different);

    if (current->render_and_frame_size_different) {
        f(16, render_width_minus_1);
        f(16, render_height_minus_1);
    }

    return 0;
}

static int FUNC(frame_size_with_refs)(CodedBitstreamContext *ctx, RWContext *rw,
                                      VP9RawFrameHeader *current)
{
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
    int err, i;

    for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
        fs(1, found_ref[i], 1, i);
        if (current->found_ref[i]) {
            VP9ReferenceFrameState *ref =
                &vp9->ref[current->ref_frame_idx[i]];

            vp9->frame_width   = ref->frame_width;
            vp9->frame_height  = ref->frame_height;

            vp9->subsampling_x = ref->subsampling_x;
            vp9->subsampling_y = ref->subsampling_y;
            vp9->bit_depth     = ref->bit_depth;

            break;
        }
    }
    if (i >= VP9_REFS_PER_FRAME)
        CHECK(FUNC(frame_size)(ctx, rw, current));
    else {
        vp9->mi_cols = (vp9->frame_width  + 7) >> 3;
        vp9->mi_rows = (vp9->frame_height + 7) >> 3;
        vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
        vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;
    }
    CHECK(FUNC(render_size)(ctx, rw, current));

    return 0;
}

static int FUNC(interpolation_filter)(CodedBitstreamContext *ctx, RWContext *rw,
                                      VP9RawFrameHeader *current)
{
    int err;

    f(1, is_filter_switchable);
    if (!current->is_filter_switchable)
        f(2, raw_interpolation_filter_type);

    return 0;
}

static int FUNC(loop_filter_params)(CodedBitstreamContext *ctx, RWContext *rw,
                                    VP9RawFrameHeader *current)
{
    int err, i;

    f(6, loop_filter_level);
    f(3, loop_filter_sharpness);

    f(1, loop_filter_delta_enabled);
    if (current->loop_filter_delta_enabled) {
        f(1, loop_filter_delta_update);
        if (current->loop_filter_delta_update) {
            for (i = 0; i < VP9_MAX_REF_FRAMES; i++) {
                fs(1, update_ref_delta[i], 1, i);
                if (current->update_ref_delta[i])
                    ss(6, loop_filter_ref_deltas[i], 1, i);
            }
            for (i = 0; i < 2; i++) {
                fs(1, update_mode_delta[i], 1, i);
                if (current->update_mode_delta[i])
                    ss(6, loop_filter_mode_deltas[i], 1, i);
            }
        }
    }

    return 0;
}

static int FUNC(quantization_params)(CodedBitstreamContext *ctx, RWContext *rw,
                                     VP9RawFrameHeader *current)
{
    int err;

    f(8, base_q_idx);

    delta_q(delta_q_y_dc);
    delta_q(delta_q_uv_dc);
    delta_q(delta_q_uv_ac);

    return 0;
}

static int FUNC(segmentation_params)(CodedBitstreamContext *ctx, RWContext *rw,
                                     VP9RawFrameHeader *current)
{
    static const uint8_t segmentation_feature_bits[VP9_SEG_LVL_MAX]   = { 8, 6, 2, 0 };
    static const uint8_t segmentation_feature_signed[VP9_SEG_LVL_MAX] = { 1, 1, 0, 0 };

    int err, i, j;

    f(1, segmentation_enabled);

    if (current->segmentation_enabled) {
        f(1, segmentation_update_map);
        if (current->segmentation_update_map) {
            for (i = 0; i < 7; i++)
                prob(segmentation_tree_probs[i], 1, i);
            f(1, segmentation_temporal_update);
            for (i = 0; i < 3; i++) {
                if (current->segmentation_temporal_update)
                    prob(segmentation_pred_prob[i], 1, i);
                else
                    infer(segmentation_pred_prob[i], 255);
            }
        }

        f(1, segmentation_update_data);
        if (current->segmentation_update_data) {
            f(1, segmentation_abs_or_delta_update);
            for (i = 0; i < VP9_MAX_SEGMENTS; i++) {
                for (j = 0; j < VP9_SEG_LVL_MAX; j++) {
                    fs(1, feature_enabled[i][j], 2, i, j);
                    if (current->feature_enabled[i][j] &&
                        segmentation_feature_bits[j]) {
                        fs(segmentation_feature_bits[j],
                           feature_value[i][j], 2, i, j);
                        if (segmentation_feature_signed[j])
                            fs(1, feature_sign[i][j], 2, i, j);
                        else
                            infer(feature_sign[i][j], 0);
                    } else {
                        infer(feature_value[i][j], 0);
                        infer(feature_sign[i][j],  0);
                    }
                }
            }
        }
    }

    return 0;
}

static int FUNC(tile_info)(CodedBitstreamContext *ctx, RWContext *rw,
                           VP9RawFrameHeader *current)
{
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
    int min_log2_tile_cols, max_log2_tile_cols;
    int err;

    min_log2_tile_cols = 0;
    while ((VP9_MAX_TILE_WIDTH_B64 << min_log2_tile_cols) < vp9->sb64_cols)
        ++min_log2_tile_cols;
    max_log2_tile_cols = 0;
    while ((vp9->sb64_cols >> (max_log2_tile_cols + 1)) >= VP9_MIN_TILE_WIDTH_B64)
        ++max_log2_tile_cols;

    increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);

    increment(tile_rows_log2, 0, 2);

    return 0;
}

static int FUNC(uncompressed_header)(CodedBitstreamContext *ctx, RWContext *rw,
                                     VP9RawFrameHeader *current)
{
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
    int err, i;

    f(2, frame_marker);

    f(1, profile_low_bit);
    f(1, profile_high_bit);
    vp9->profile = (current->profile_high_bit << 1) + current->profile_low_bit;
    if (vp9->profile == 3)
        fixed(1, reserved_zero, 0);

    f(1, show_existing_frame);
    if (current->show_existing_frame) {
        f(3, frame_to_show_map_idx);
        infer(header_size_in_bytes, 0);
        infer(refresh_frame_flags,  0x00);
        infer(loop_filter_level,    0);
        return 0;
    }

    f(1, frame_type);
    f(1, show_frame);
    f(1, error_resilient_mode);

    if (current->frame_type == VP9_KEY_FRAME) {
        CHECK(FUNC(frame_sync_code)(ctx, rw, current));
        CHECK(FUNC(color_config)(ctx, rw, current, vp9->profile));
        CHECK(FUNC(frame_size)(ctx, rw, current));
        CHECK(FUNC(render_size)(ctx, rw, current));

        infer(refresh_frame_flags, 0xff);

    } else {
         if (current->show_frame == 0)
             f(1, intra_only);
         else
             infer(intra_only, 0);

         if (current->error_resilient_mode == 0)
             f(2, reset_frame_context);
         else
             infer(reset_frame_context, 0);

         if (current->intra_only == 1) {
             CHECK(FUNC(frame_sync_code)(ctx, rw, current));

             if (vp9->profile > 0) {
                 CHECK(FUNC(color_config)(ctx, rw, current, vp9->profile));
             } else {
                 infer(color_space,   1);
                 infer(subsampling_x, 1);
                 infer(subsampling_y, 1);
                 vp9->bit_depth = 8;

                 vp9->subsampling_x = current->subsampling_x;
                 vp9->subsampling_y = current->subsampling_y;
             }

             f(8, refresh_frame_flags);

             CHECK(FUNC(frame_size)(ctx, rw, current));
             CHECK(FUNC(render_size)(ctx, rw, current));
         } else {
             f(8, refresh_frame_flags);

             for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
                 fs(3, ref_frame_idx[i], 1, i);
                 fs(1, ref_frame_sign_bias[VP9_LAST_FRAME + i],
                    1, VP9_LAST_FRAME + i);
             }

             CHECK(FUNC(frame_size_with_refs)(ctx, rw, current));
             f(1, allow_high_precision_mv);
             CHECK(FUNC(interpolation_filter)(ctx, rw, current));
         }
    }

    if (current->error_resilient_mode == 0) {
        f(1, refresh_frame_context);
        f(1, frame_parallel_decoding_mode);
    } else {
        infer(refresh_frame_context,        0);
        infer(frame_parallel_decoding_mode, 1);
    }

    f(2, frame_context_idx);

    CHECK(FUNC(loop_filter_params)(ctx, rw, current));
    CHECK(FUNC(quantization_params)(ctx, rw, current));
    CHECK(FUNC(segmentation_params)(ctx, rw, current));
    CHECK(FUNC(tile_info)(ctx, rw, current));

    f(16, header_size_in_bytes);

    for (i = 0; i < VP9_NUM_REF_FRAMES; i++) {
        if (current->refresh_frame_flags & (1 << i)) {
            vp9->ref[i] = (VP9ReferenceFrameState) {
                .frame_width    = vp9->frame_width,
                .frame_height   = vp9->frame_height,
                .subsampling_x  = vp9->subsampling_x,
                .subsampling_y  = vp9->subsampling_y,
                .bit_depth      = vp9->bit_depth,
            };
        }
    }

    av_log(ctx->log_ctx, AV_LOG_DEBUG, "Frame:  size %dx%d  "
           "subsample %dx%d  bit_depth %d  tiles %dx%d.\n",
           vp9->frame_width, vp9->frame_height,
           vp9->subsampling_x, vp9->subsampling_y,
           vp9->bit_depth, 1 << current->tile_cols_log2,
           1 << current->tile_rows_log2);

    return 0;
}

static int FUNC(trailing_bits)(CodedBitstreamContext *ctx, RWContext *rw)
{
    int err;
    av_unused int zero = 0;
    while (byte_alignment(rw) != 0)
        xf(1, zero_bit, zero, 0);

    return 0;
}

static int FUNC(frame)(CodedBitstreamContext *ctx, RWContext *rw,
                       VP9RawFrame *current)
{
    int err;

    HEADER("Frame");

    CHECK(FUNC(uncompressed_header)(ctx, rw, &current->header));

    CHECK(FUNC(trailing_bits)(ctx, rw));

    return 0;
}

static int FUNC(superframe_index)(CodedBitstreamContext *ctx, RWContext *rw,
                                  VP9RawSuperframeIndex *current)
{
    int err, i;

    HEADER("Superframe Index");

    f(3, superframe_marker);
    f(2, bytes_per_framesize_minus_1);
    f(3, frames_in_superframe_minus_1);

    for (i = 0; i <= current->frames_in_superframe_minus_1; i++) {
        // Surprise little-endian!
        fle(8 * (current->bytes_per_framesize_minus_1 + 1),
            frame_sizes[i], 1, i);
    }

    f(3, superframe_marker);
    f(2, bytes_per_framesize_minus_1);
    f(3, frames_in_superframe_minus_1);

    return 0;
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
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		56	static int FUNC(frame_sync_code)(CodedBitstreamContext ctx, RWContext rw,
20			VP9RawFrameHeader *current)
21			{
22		56	uint8_t frame_sync_byte_0 = VP9_FRAME_SYNC_0;
23		56	uint8_t frame_sync_byte_1 = VP9_FRAME_SYNC_1;
24		56	uint8_t frame_sync_byte_2 = VP9_FRAME_SYNC_2;
25			int err;
26
27	✗✓	56	xf(8, frame_sync_byte_0, frame_sync_byte_0, 0);
28	✗✓	56	xf(8, frame_sync_byte_1, frame_sync_byte_1, 0);
29	✗✓	56	xf(8, frame_sync_byte_2, frame_sync_byte_2, 0);
30
31	✓✗✓✗	56	if (frame_sync_byte_0 != VP9_FRAME_SYNC_0 \|\|
32	✗✓	56	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;
38			}
39
40		56	return 0;
41			}
42
43		56	static int FUNC(color_config)(CodedBitstreamContext ctx, RWContext rw,
44			VP9RawFrameHeader *current, int profile)
45			{
46		56	CodedBitstreamVP9Context *vp9 = ctx->priv_data;
47			int err;
48
49	✓✓	56	if (profile >= 2) {
50	✗✓	12	f(1, ten_or_twelve_bit);
51	✓✓	12	vp9->bit_depth = current->ten_or_twelve_bit ? 12 : 10;
52			} else
53		44	vp9->bit_depth = 8;
54
55	✗✓	56	f(3, color_space);
56
57	✓✗	56	if (current->color_space != VP9_CS_RGB) {
58	✗✓	56	f(1, color_range);
59	✓✓✓✓	56	if (profile == 1 \|\| profile == 3) {
60	✗✓	16	f(1, subsampling_x);
61	✗✓	16	f(1, subsampling_y);
62	✗✓	16	fixed(1, reserved_zero, 0);
63			} else {
64	✗✓	40	infer(subsampling_x, 1);
65	✗✓	40	infer(subsampling_y, 1);
66			}
67			} else {
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);
73			}
74			}
75
76		56	vp9->subsampling_x = current->subsampling_x;
77		56	vp9->subsampling_y = current->subsampling_y;
78
79		56	return 0;
80			}
81
82		60	static int FUNC(frame_size)(CodedBitstreamContext ctx, RWContext rw,
83			VP9RawFrameHeader *current)
84			{
85		60	CodedBitstreamVP9Context *vp9 = ctx->priv_data;
86			int err;
87
88	✗✓	60	f(16, frame_width_minus_1);
89	✗✓	60	f(16, frame_height_minus_1);
90
91		60	vp9->frame_width = current->frame_width_minus_1 + 1;
92		60	vp9->frame_height = current->frame_height_minus_1 + 1;
93
94		60	vp9->mi_cols = (vp9->frame_width + 7) >> 3;
95		60	vp9->mi_rows = (vp9->frame_height + 7) >> 3;
96		60	vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
97		60	vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;
98
99		60	return 0;
100			}
101
102		724	static int FUNC(render_size)(CodedBitstreamContext ctx, RWContext rw,
103			VP9RawFrameHeader *current)
104			{
105			int err;
106
107	✗✓	724	f(1, render_and_frame_size_different);
108
109	✓✓	724	if (current->render_and_frame_size_different) {
110	✗✓	12	f(16, render_width_minus_1);
111	✗✓	12	f(16, render_height_minus_1);
112			}
113
114		724	return 0;
115			}
116
117		668	static int FUNC(frame_size_with_refs)(CodedBitstreamContext ctx, RWContext rw,
118			VP9RawFrameHeader *current)
119			{
120		668	CodedBitstreamVP9Context *vp9 = ctx->priv_data;
121			int err, i;
122
123	✓✓	684	for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
124	✗✓	680	fs(1, found_ref[i], 1, i);
125	✓✓	680	if (current->found_ref[i]) {
126		664	VP9ReferenceFrameState *ref =
127		664	&vp9->ref[current->ref_frame_idx[i]];
128
129		664	vp9->frame_width = ref->frame_width;
130		664	vp9->frame_height = ref->frame_height;
131
132		664	vp9->subsampling_x = ref->subsampling_x;
133		664	vp9->subsampling_y = ref->subsampling_y;
134		664	vp9->bit_depth = ref->bit_depth;
135
136		664	break;
137			}
138			}
139	✓✓	668	if (i >= VP9_REFS_PER_FRAME)
140	✗✓	4	CHECK(FUNC(frame_size)(ctx, rw, current));
141			else {
142		664	vp9->mi_cols = (vp9->frame_width + 7) >> 3;
143		664	vp9->mi_rows = (vp9->frame_height + 7) >> 3;
144		664	vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
145		664	vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;
146			}
147	✗✓	668	CHECK(FUNC(render_size)(ctx, rw, current));
148
149		668	return 0;
150			}
151
152		668	static int FUNC(interpolation_filter)(CodedBitstreamContext ctx, RWContext rw,
153			VP9RawFrameHeader *current)
154			{
155			int err;
156
157	✗✓	668	f(1, is_filter_switchable);
158	✓✓	668	if (!current->is_filter_switchable)
159	✗✓	320	f(2, raw_interpolation_filter_type);
160
161		668	return 0;
162			}
163
164		724	static int FUNC(loop_filter_params)(CodedBitstreamContext ctx, RWContext rw,
165			VP9RawFrameHeader *current)
166			{
167			int err, i;
168
169	✗✓	724	f(6, loop_filter_level);
170	✗✓	724	f(3, loop_filter_sharpness);
171
172	✗✓	724	f(1, loop_filter_delta_enabled);
173	✓✓	724	if (current->loop_filter_delta_enabled) {
174	✗✓	664	f(1, loop_filter_delta_update);
175	✓✓	664	if (current->loop_filter_delta_update) {
176	✓✓	560	for (i = 0; i < VP9_MAX_REF_FRAMES; i++) {
177	✗✓	448	fs(1, update_ref_delta[i], 1, i);
178	✓✓	448	if (current->update_ref_delta[i])
179	✗✓	180	ss(6, loop_filter_ref_deltas[i], 1, i);
180			}
181	✓✓	336	for (i = 0; i < 2; i++) {
182	✗✓	224	fs(1, update_mode_delta[i], 1, i);
183	✓✓	224	if (current->update_mode_delta[i])
184	✗✓	8	ss(6, loop_filter_mode_deltas[i], 1, i);
185			}
186			}
187			}
188
189		724	return 0;
190			}
191
192		724	static int FUNC(quantization_params)(CodedBitstreamContext ctx, RWContext rw,
193			VP9RawFrameHeader *current)
194			{
195			int err;
196
197	✗✓	724	f(8, base_q_idx);
198
199	✗✓✓✓ ✗✓	724	delta_q(delta_q_y_dc);
200	✗✓✓✓ ✗✓	724	delta_q(delta_q_uv_dc);
201	✗✓✓✓ ✗✓	724	delta_q(delta_q_uv_ac);
202
203		724	return 0;
204			}
205
206		724	static int FUNC(segmentation_params)(CodedBitstreamContext ctx, RWContext rw,
207			VP9RawFrameHeader *current)
208			{
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 };
211
212			int err, i, j;
213
214	✗✓	724	f(1, segmentation_enabled);
215
216	✓✓	724	if (current->segmentation_enabled) {
217	✗✓	172	f(1, segmentation_update_map);
218	✓✓	172	if (current->segmentation_update_map) {
219	✓✓	864	for (i = 0; i < 7; i++)
220	✗✓✓✓ ✗✓	756	prob(segmentation_tree_probs[i], 1, i);
221	✗✓	108	f(1, segmentation_temporal_update);
222	✓✓	432	for (i = 0; i < 3; i++) {
223	✓✓	324	if (current->segmentation_temporal_update)
224	✗✓✓✗ ✗✓	312	prob(segmentation_pred_prob[i], 1, i);
225			else
226	✗✓	12	infer(segmentation_pred_prob[i], 255);
227			}
228			}
229
230	✗✓	172	f(1, segmentation_update_data);
231	✓✓	172	if (current->segmentation_update_data) {
232	✗✓	116	f(1, segmentation_abs_or_delta_update);
233	✓✓	1044	for (i = 0; i < VP9_MAX_SEGMENTS; i++) {
234	✓✓	4640	for (j = 0; j < VP9_SEG_LVL_MAX; j++) {
235	✗✓	3712	fs(1, feature_enabled[i][j], 2, i, j);
236	✓✓	3712	if (current->feature_enabled[i][j] &&
237	✓✓	672	segmentation_feature_bits[j]) {
238	✗✓	660	fs(segmentation_feature_bits[j],
239			feature_value[i][j], 2, i, j);
240	✓✓	660	if (segmentation_feature_signed[j])
241	✗✓	648	fs(1, feature_sign[i][j], 2, i, j);
242			else
243	✗✓	12	infer(feature_sign[i][j], 0);
244			} else {
245	✗✓	3052	infer(feature_value[i][j], 0);
246	✗✓	3052	infer(feature_sign[i][j], 0);
247			}
248			}
249			}
250			}
251			}
252
253		724	return 0;
254			}
255
256		724	static int FUNC(tile_info)(CodedBitstreamContext ctx, RWContext rw,
257			VP9RawFrameHeader *current)
258			{
259		724	CodedBitstreamVP9Context *vp9 = ctx->priv_data;
260			int min_log2_tile_cols, max_log2_tile_cols;
261			int err;
262
263		724	min_log2_tile_cols = 0;
264	✗✓	724	while ((VP9_MAX_TILE_WIDTH_B64 << min_log2_tile_cols) < vp9->sb64_cols)
265			++min_log2_tile_cols;
266		724	max_log2_tile_cols = 0;
267	✓✓	740	while ((vp9->sb64_cols >> (max_log2_tile_cols + 1)) >= VP9_MIN_TILE_WIDTH_B64)
268		16	++max_log2_tile_cols;
269
270	✗✓	724	increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);
271
272	✗✓	724	increment(tile_rows_log2, 0, 2);
273
274		724	return 0;
275			}
276
277		788	static int FUNC(uncompressed_header)(CodedBitstreamContext ctx, RWContext rw,
278			VP9RawFrameHeader *current)
279			{
280		788	CodedBitstreamVP9Context *vp9 = ctx->priv_data;
281			int err, i;
282
283	✗✓	788	f(2, frame_marker);
284
285	✗✓	788	f(1, profile_low_bit);
286	✗✓	788	f(1, profile_high_bit);
287		788	vp9->profile = (current->profile_high_bit << 1) + current->profile_low_bit;
288	✓✓	788	if (vp9->profile == 3)
289	✗✓	88	fixed(1, reserved_zero, 0);
290
291	✗✓	788	f(1, show_existing_frame);
292	✓✓	788	if (current->show_existing_frame) {
293	✗✓	64	f(3, frame_to_show_map_idx);
294	✗✓	64	infer(header_size_in_bytes, 0);
295	✗✓	64	infer(refresh_frame_flags, 0x00);
296	✗✓	64	infer(loop_filter_level, 0);
297		64	return 0;
298			}
299
300	✗✓	724	f(1, frame_type);
301	✗✓	724	f(1, show_frame);
302	✗✓	724	f(1, error_resilient_mode);
303
304	✓✓	724	if (current->frame_type == VP9_KEY_FRAME) {
305	✗✓	56	CHECK(FUNC(frame_sync_code)(ctx, rw, current));
306	✗✓	56	CHECK(FUNC(color_config)(ctx, rw, current, vp9->profile));
307	✗✓	56	CHECK(FUNC(frame_size)(ctx, rw, current));
308	✗✓	56	CHECK(FUNC(render_size)(ctx, rw, current));
309
310	✗✓	56	infer(refresh_frame_flags, 0xff);
311
312			} else {
313	✓✓	668	if (current->show_frame == 0)
314	✗✓	56	f(1, intra_only);
315			else
316	✗✓	612	infer(intra_only, 0);
317
318	✓✗	668	if (current->error_resilient_mode == 0)
319	✗✓	668	f(2, reset_frame_context);
320			else
321			infer(reset_frame_context, 0);
322
323	✗✓	668	if (current->intra_only == 1) {
324			CHECK(FUNC(frame_sync_code)(ctx, rw, current));
325
326			if (vp9->profile > 0) {
327			CHECK(FUNC(color_config)(ctx, rw, current, vp9->profile));
328			} else {
329			infer(color_space, 1);
330			infer(subsampling_x, 1);
331			infer(subsampling_y, 1);
332			vp9->bit_depth = 8;
333
334			vp9->subsampling_x = current->subsampling_x;
335			vp9->subsampling_y = current->subsampling_y;
336			}
337
338			f(8, refresh_frame_flags);
339
340			CHECK(FUNC(frame_size)(ctx, rw, current));
341			CHECK(FUNC(render_size)(ctx, rw, current));
342			} else {
343	✗✓	668	f(8, refresh_frame_flags);
344
345	✓✓	2672	for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
346	✗✓	2004	fs(3, ref_frame_idx[i], 1, i);
347	✗✓	2004	fs(1, ref_frame_sign_bias[VP9_LAST_FRAME + i],
348			1, VP9_LAST_FRAME + i);
349			}
350
351	✗✓	668	CHECK(FUNC(frame_size_with_refs)(ctx, rw, current));
352	✗✓	668	f(1, allow_high_precision_mv);
353	✗✓	668	CHECK(FUNC(interpolation_filter)(ctx, rw, current));
354			}
355			}
356
357	✓✗	724	if (current->error_resilient_mode == 0) {
358	✗✓	724	f(1, refresh_frame_context);
359	✗✓	724	f(1, frame_parallel_decoding_mode);
360			} else {
361			infer(refresh_frame_context, 0);
362			infer(frame_parallel_decoding_mode, 1);
363			}
364
365	✗✓	724	f(2, frame_context_idx);
366
367	✗✓	724	CHECK(FUNC(loop_filter_params)(ctx, rw, current));
368	✗✓	724	CHECK(FUNC(quantization_params)(ctx, rw, current));
369	✗✓	724	CHECK(FUNC(segmentation_params)(ctx, rw, current));
370	✗✓	724	CHECK(FUNC(tile_info)(ctx, rw, current));
371
372	✗✓	724	f(16, header_size_in_bytes);
373
374	✓✓	6516	for (i = 0; i < VP9_NUM_REF_FRAMES; i++) {
375	✓✓	5792	if (current->refresh_frame_flags & (1 << i)) {
376		1152	vp9->ref[i] = (VP9ReferenceFrameState) {
377		1152	.frame_width = vp9->frame_width,
378		1152	.frame_height = vp9->frame_height,
379		1152	.subsampling_x = vp9->subsampling_x,
380		1152	.subsampling_y = vp9->subsampling_y,
381		1152	.bit_depth = vp9->bit_depth,
382			};
383			}
384			}
385
386		724	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		724	vp9->subsampling_x, vp9->subsampling_y,
390		724	vp9->bit_depth, 1 << current->tile_cols_log2,
391		724	1 << current->tile_rows_log2);
392
393		724	return 0;
394			}
395
396		788	static int FUNC(trailing_bits)(CodedBitstreamContext ctx, RWContext rw)
397			{
398			int err;
399		788	av_unused int zero = 0;
400	✓✓	2612	while (byte_alignment(rw) != 0)
401	✗✓	1824	xf(1, zero_bit, zero, 0);
402
403		788	return 0;
404			}
405
406		788	static int FUNC(frame)(CodedBitstreamContext ctx, RWContext rw,
407			VP9RawFrame *current)
408			{
409			int err;
410
411		788	HEADER("Frame");
412
413	✗✓	788	CHECK(FUNC(uncompressed_header)(ctx, rw, &current->header));
414
415	✗✓	788	CHECK(FUNC(trailing_bits)(ctx, rw));
416
417		788	return 0;
418			}
419
420		26	static int FUNC(superframe_index)(CodedBitstreamContext ctx, RWContext rw,
421			VP9RawSuperframeIndex *current)
422			{
423			int err, i;
424
425		26	HEADER("Superframe Index");
426
427		26	f(3, superframe_marker);
428		26	f(2, bytes_per_framesize_minus_1);
429		26	f(3, frames_in_superframe_minus_1);
430
431		80	for (i = 0; i <= current->frames_in_superframe_minus_1; i++) {
432			// Surprise little-endian!
433		54	fle(8 * (current->bytes_per_framesize_minus_1 + 1),
434			frame_sizes[i], 1, i);
435			}
436
437		26	f(3, superframe_marker);
438		26	f(2, bytes_per_framesize_minus_1);
439		26	f(3, frames_in_superframe_minus_1);
440
441		26	return 0;
442			}