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