FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/cbs_vp8_syntax_template.c
Date: 2024-04-20 14:10:07
Exec Total Coverage
Lines: 0 131 0.0%
Functions: 0 9 0.0%
Branches: 0 224 0.0%

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 static int FUNC(update_segmentation)(CodedBitstreamContext *ctx,
20 CBSVP8BoolCodingRW *bool_coding_rw,
21 VP8RawFrameHeader *current)
22 {
23 bc_f(1, update_segment_map);
24 bc_f(1, update_segment_feature_data);
25
26 if (current->update_segment_feature_data) {
27 bc_f(1, segment_feature_mode);
28 // quantizer
29 for (int i = 0; i < 4; i++) {
30 bc_b(segment_qp_update[i]);
31 if (current->segment_qp_update[i])
32 bc_ss(7, segment_qp[i], 1, i);
33 }
34 // loop filter
35 for (int i = 0; i < 4; i++) {
36 bc_b(segment_loop_filter_level_update[i]);
37 if (current->segment_loop_filter_level_update[i])
38 bc_ss(6, segment_loop_filter_level[i], 1, i);
39 }
40 }
41
42 if (current->update_segment_map) {
43 for (int i = 0; i < 3; i++) {
44 bc_b(segment_probs_update[i]);
45 if (current->segment_probs_update[i])
46 bc_fs(8, segment_probs[i], 1, i);
47 }
48 }
49
50 return 0;
51 }
52
53 static int FUNC(mode_ref_lf_deltas)(CodedBitstreamContext *ctx,
54 CBSVP8BoolCodingRW *bool_coding_rw,
55 VP8RawFrameHeader *current)
56 {
57 bc_f(1, mode_ref_lf_delta_enable);
58 if (current->mode_ref_lf_delta_enable) {
59 bc_b(mode_ref_lf_delta_update);
60 if (current->mode_ref_lf_delta_update) {
61 // ref_lf_deltas
62 for (int i = 0; i < 4; i++) {
63 bc_b(ref_lf_deltas_update[i]);
64 if (current->ref_lf_deltas_update[i])
65 bc_ss(6, ref_lf_deltas[i], 1, i);
66 }
67 // mode_lf_deltas
68 for (int i = 0; i < 4; i++) {
69 bc_b(mode_lf_deltas_update[i]);
70 if (current->mode_lf_deltas_update[i])
71 bc_ss(6, mode_lf_deltas[i], 1, i);
72 }
73 }
74 }
75
76 return 0;
77 }
78
79 static int FUNC(quantization_params)(CodedBitstreamContext *ctx,
80 CBSVP8BoolCodingRW *bool_coding_rw,
81 VP8RawFrameHeader *current)
82 {
83 bc_f(7, base_qindex);
84
85 bc_b(y1dc_delta_q_present);
86 if (current->y1dc_delta_q_present)
87 bc_s(4, y1dc_delta_q);
88
89 bc_b(y2dc_delta_q_present);
90 if (current->y2dc_delta_q_present)
91 bc_s(4, y2dc_delta_q);
92
93 bc_b(y2ac_delta_q_present);
94 if (current->y2ac_delta_q_present)
95 bc_s(4, y2ac_delta_q);
96
97 bc_b(uvdc_delta_q_present);
98 if (current->uvdc_delta_q_present)
99 bc_s(4, uvdc_delta_q);
100
101 bc_b(uvac_delta_q_present);
102 if (current->uvac_delta_q_present)
103 bc_s(4, uvac_delta_q);
104
105 return 0;
106 }
107
108 static int FUNC(update_token_probs)(CodedBitstreamContext *ctx,
109 CBSVP8BoolCodingRW *bool_coding_rw,
110 VP8RawFrameHeader *current)
111 {
112 for (int i = 0; i < 4; ++i) {
113 for (int j = 0; j < 8; ++j) {
114 for (int k = 0; k < 3; ++k) {
115 for (int l = 0; l < 11; ++l) {
116 bc_b_prob(ff_vp8_token_update_probs[i][j][k][l],
117 coeff_prob_update[i][j][k][l]);
118 if (current->coeff_prob_update[i][j][k][l])
119 bc_fs(8, coeff_prob[i][j][k][l], 4, i, j, k, l);
120 }
121 }
122 }
123 }
124
125 return 0;
126 }
127
128 static int FUNC(update_mv_probs)(CodedBitstreamContext *ctx,
129 CBSVP8BoolCodingRW *bool_coding_rw,
130 VP8RawFrameHeader *current)
131 {
132 for (int i = 0; i < 2; ++i) {
133 for (int j = 0; j < 19; ++j) {
134 bc_b(mv_prob_update[i][j]);
135 if (current->mv_prob_update[i][j])
136 bc_fs(7, mv_prob[i][j], 2, i, j);
137 }
138 }
139
140 return 0;
141 }
142
143 static int FUNC(frame_tag)(CodedBitstreamContext *ctx, RWContext *rw,
144 VP8RawFrameHeader *current)
145 {
146 f(1, frame_type);
147 f(3, profile);
148 f(1, show_frame);
149 f(19, first_partition_length_in_bytes);
150
151 if (current->frame_type == VP8_KEY_FRAME) {
152 fixed(8, start_code_0, VP8_START_CODE_0);
153 fixed(8, start_code_1, VP8_START_CODE_1);
154 fixed(8, start_code_2, VP8_START_CODE_2);
155
156 f(14, width);
157 f(2, horizontal_scale);
158 f(14, height);
159 f(2, vertical_scale);
160 }
161
162 return 0;
163 }
164
165 static int FUNC(frame_header)(CodedBitstreamContext *ctx,
166 CBSVP8BoolCodingRW *bool_coding_rw,
167 VP8RawFrameHeader *current)
168 {
169 if (current->frame_type == VP8_KEY_FRAME) {
170 bc_f(1, color_space);
171 bc_f(1, clamping_type);
172 }
173
174 bc_f(1, segmentation_enable);
175 if (current->segmentation_enable)
176 CHECK(FUNC(update_segmentation)(ctx, bool_coding_rw, current));
177
178 bc_f(1, loop_filter_type);
179 bc_f(6, loop_filter_level);
180 bc_f(3, loop_filter_sharpness);
181
182 CHECK(FUNC(mode_ref_lf_deltas)(ctx, bool_coding_rw, current));
183
184 bc_f(2, log2_token_partitions);
185
186 CHECK(FUNC(quantization_params)(ctx, bool_coding_rw, current));
187
188 if (current->frame_type != VP8_KEY_FRAME) {
189 bc_f(1, refresh_golden_frame);
190 bc_f(1, refresh_alternate_frame);
191 if (!current->refresh_golden_frame)
192 bc_f(2, copy_buffer_to_golden);
193 if (!current->refresh_alternate_frame)
194 bc_f(2, copy_buffer_to_alternate);
195 bc_f(1, ref_frame_sign_bias_golden);
196 bc_f(1, ref_frame_sign_bias_alternate);
197 }
198 bc_f(1, refresh_entropy_probs);
199 if (current->frame_type != VP8_KEY_FRAME)
200 bc_f(1, refresh_last_frame);
201
202 CHECK(FUNC(update_token_probs)(ctx, bool_coding_rw, current));
203
204 bc_f(1, mb_no_skip_coeff);
205 if (current->mb_no_skip_coeff)
206 bc_f(8, prob_skip_false);
207
208 if (current->frame_type != VP8_KEY_FRAME) {
209 bc_f(8, prob_intra);
210 bc_f(8, prob_last);
211 bc_f(8, prob_golden);
212
213 // intra_16x16_prob
214 bc_b(intra_16x16_prob_update);
215 if (current->intra_16x16_prob_update)
216 for (int i = 0; i < 4; i++)
217 bc_fs(8, intra_16x16_prob[i], 1, i);
218
219 // intra_chroma_prob
220 bc_b(intra_chrome_prob_update);
221 if (current->intra_chrome_prob_update)
222 for (int i = 0; i < 3; i++)
223 bc_fs(8, intra_chrome_prob[i], 1, i);
224
225 CHECK(FUNC(update_mv_probs)(ctx, bool_coding_rw, current));
226 }
227
228 return 0;
229 }
230
231 static int FUNC(uncompressed_header)(CodedBitstreamContext *ctx, RWContext *rw,
232 VP8RawFrame *current)
233 {
234 HEADER("Frame");
235
236 CHECK(FUNC(frame_tag)(ctx, rw, &current->header));
237
238 return 0;
239 }
240
241 static int FUNC(compressed_header)(CodedBitstreamContext *ctx,
242 CBSVP8BoolCodingRW *bool_coding_rw,
243 VP8RawFrame *current)
244 {
245 CHECK(FUNC(frame_header)(ctx, bool_coding_rw, &current->header));
246
247 return 0;
248 }
249