GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/cbs_vp9_syntax_template.c Lines: 210 233 90.1 %
Date: 2019-11-20 04:07:19 Branches: 178 314 56.7 %

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
14
static int FUNC(frame_sync_code)(CodedBitstreamContext *ctx, RWContext *rw,
20
                                 VP9RawFrameHeader *current)
21
{
22
14
    uint8_t frame_sync_byte_0 = VP9_FRAME_SYNC_0;
23
14
    uint8_t frame_sync_byte_1 = VP9_FRAME_SYNC_1;
24
14
    uint8_t frame_sync_byte_2 = VP9_FRAME_SYNC_2;
25
    int err;
26
27
14
    xf(8, frame_sync_byte_0, frame_sync_byte_0, 0);
28
14
    xf(8, frame_sync_byte_1, frame_sync_byte_1, 0);
29
14
    xf(8, frame_sync_byte_2, frame_sync_byte_2, 0);
30
31

14
    if (frame_sync_byte_0 != VP9_FRAME_SYNC_0 ||
32
14
        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
14
    return 0;
41
}
42
43
14
static int FUNC(color_config)(CodedBitstreamContext *ctx, RWContext *rw,
44
                              VP9RawFrameHeader *current, int profile)
45
{
46
14
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
47
    int err;
48
49
14
    if (profile >= 2) {
50
3
        f(1, ten_or_twelve_bit);
51
3
        vp9->bit_depth = current->ten_or_twelve_bit ? 12 : 10;
52
    } else
53
11
        vp9->bit_depth = 8;
54
55
14
    f(3, color_space);
56
57
14
    if (current->color_space != VP9_CS_RGB) {
58
14
        f(1, color_range);
59

14
        if (profile == 1 || profile == 3) {
60
4
            f(1, subsampling_x);
61
4
            f(1, subsampling_y);
62
4
            fixed(1, reserved_zero, 0);
63
        } else {
64
10
            infer(subsampling_x, 1);
65
10
            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
14
    vp9->subsampling_x = current->subsampling_x;
77
14
    vp9->subsampling_y = current->subsampling_y;
78
79
14
    return 0;
80
}
81
82
15
static int FUNC(frame_size)(CodedBitstreamContext *ctx, RWContext *rw,
83
                            VP9RawFrameHeader *current)
84
{
85
15
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
86
    int err;
87
88
15
    f(16, frame_width_minus_1);
89
15
    f(16, frame_height_minus_1);
90
91
15
    vp9->frame_width  = current->frame_width_minus_1  + 1;
92
15
    vp9->frame_height = current->frame_height_minus_1 + 1;
93
94
15
    vp9->mi_cols = (vp9->frame_width  + 7) >> 3;
95
15
    vp9->mi_rows = (vp9->frame_height + 7) >> 3;
96
15
    vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
97
15
    vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;
98
99
15
    return 0;
100
}
101
102
181
static int FUNC(render_size)(CodedBitstreamContext *ctx, RWContext *rw,
103
                             VP9RawFrameHeader *current)
104
{
105
    int err;
106
107
181
    f(1, render_and_frame_size_different);
108
109
181
    if (current->render_and_frame_size_different) {
110
3
        f(16, render_width_minus_1);
111
3
        f(16, render_height_minus_1);
112
    }
113
114
181
    return 0;
115
}
116
117
167
static int FUNC(frame_size_with_refs)(CodedBitstreamContext *ctx, RWContext *rw,
118
                                      VP9RawFrameHeader *current)
119
{
120
167
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
121
    int err, i;
122
123
171
    for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
124
170
        fs(1, found_ref[i], 1, i);
125
170
        if (current->found_ref[i]) {
126
166
            VP9ReferenceFrameState *ref =
127
166
                &vp9->ref[current->ref_frame_idx[i]];
128
129
166
            vp9->frame_width   = ref->frame_width;
130
166
            vp9->frame_height  = ref->frame_height;
131
132
166
            vp9->subsampling_x = ref->subsampling_x;
133
166
            vp9->subsampling_y = ref->subsampling_y;
134
166
            vp9->bit_depth     = ref->bit_depth;
135
136
166
            break;
137
        }
138
    }
139
167
    if (i >= VP9_REFS_PER_FRAME)
140
1
        CHECK(FUNC(frame_size)(ctx, rw, current));
141
    else {
142
166
        vp9->mi_cols = (vp9->frame_width  + 7) >> 3;
143
166
        vp9->mi_rows = (vp9->frame_height + 7) >> 3;
144
166
        vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
145
166
        vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;
146
    }
147
167
    CHECK(FUNC(render_size)(ctx, rw, current));
148
149
167
    return 0;
150
}
151
152
167
static int FUNC(interpolation_filter)(CodedBitstreamContext *ctx, RWContext *rw,
153
                                      VP9RawFrameHeader *current)
154
{
155
    int err;
156
157
167
    f(1, is_filter_switchable);
158
167
    if (!current->is_filter_switchable)
159
80
        f(2, raw_interpolation_filter_type);
160
161
167
    return 0;
162
}
163
164
181
static int FUNC(loop_filter_params)(CodedBitstreamContext *ctx, RWContext *rw,
165
                                    VP9RawFrameHeader *current)
166
{
167
    int err, i;
168
169
181
    f(6, loop_filter_level);
170
181
    f(3, loop_filter_sharpness);
171
172
181
    f(1, loop_filter_delta_enabled);
173
181
    if (current->loop_filter_delta_enabled) {
174
166
        f(1, loop_filter_delta_update);
175
166
        if (current->loop_filter_delta_update) {
176
140
            for (i = 0; i < VP9_MAX_REF_FRAMES; i++) {
177
112
                fs(1, update_ref_delta[i], 1, i);
178
112
                if (current->update_ref_delta[i])
179
45
                    ss(6, loop_filter_ref_deltas[i], 1, i);
180
            }
181
84
            for (i = 0; i < 2; i++) {
182
56
                fs(1, update_mode_delta[i], 1, i);
183
56
                if (current->update_mode_delta[i])
184
2
                    ss(6, loop_filter_mode_deltas[i], 1, i);
185
            }
186
        }
187
    }
188
189
181
    return 0;
190
}
191
192
181
static int FUNC(quantization_params)(CodedBitstreamContext *ctx, RWContext *rw,
193
                                     VP9RawFrameHeader *current)
194
{
195
    int err;
196
197
181
    f(8, base_q_idx);
198
199

181
    delta_q(delta_q_y_dc);
200

181
    delta_q(delta_q_uv_dc);
201

181
    delta_q(delta_q_uv_ac);
202
203
181
    return 0;
204
}
205
206
181
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
181
    f(1, segmentation_enabled);
215
216
181
    if (current->segmentation_enabled) {
217
43
        f(1, segmentation_update_map);
218
43
        if (current->segmentation_update_map) {
219
216
            for (i = 0; i < 7; i++)
220

189
                prob(segmentation_tree_probs[i], 1, i);
221
27
            f(1, segmentation_temporal_update);
222
108
            for (i = 0; i < 3; i++) {
223
81
                if (current->segmentation_temporal_update)
224

78
                    prob(segmentation_pred_prob[i], 1, i);
225
                else
226
3
                    infer(segmentation_pred_prob[i], 255);
227
            }
228
        }
229
230
43
        f(1, segmentation_update_data);
231
43
        if (current->segmentation_update_data) {
232
29
            f(1, segmentation_abs_or_delta_update);
233
261
            for (i = 0; i < VP9_MAX_SEGMENTS; i++) {
234
1160
                for (j = 0; j < VP9_SEG_LVL_MAX; j++) {
235
928
                    fs(1, feature_enabled[i][j], 2, i, j);
236
928
                    if (current->feature_enabled[i][j] &&
237
168
                        segmentation_feature_bits[j]) {
238
165
                        fs(segmentation_feature_bits[j],
239
                           feature_value[i][j], 2, i, j);
240
165
                        if (segmentation_feature_signed[j])
241
162
                            fs(1, feature_sign[i][j], 2, i, j);
242
                        else
243
3
                            infer(feature_sign[i][j], 0);
244
                    } else {
245
763
                        infer(feature_value[i][j], 0);
246
763
                        infer(feature_sign[i][j],  0);
247
                    }
248
                }
249
            }
250
        }
251
    }
252
253
181
    return 0;
254
}
255
256
181
static int FUNC(tile_info)(CodedBitstreamContext *ctx, RWContext *rw,
257
                           VP9RawFrameHeader *current)
258
{
259
181
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
260
    int min_log2_tile_cols, max_log2_tile_cols;
261
    int err;
262
263
181
    min_log2_tile_cols = 0;
264
181
    while ((VP9_MAX_TILE_WIDTH_B64 << min_log2_tile_cols) < vp9->sb64_cols)
265
        ++min_log2_tile_cols;
266
181
    max_log2_tile_cols = 0;
267
185
    while ((vp9->sb64_cols >> (max_log2_tile_cols + 1)) >= VP9_MIN_TILE_WIDTH_B64)
268
4
        ++max_log2_tile_cols;
269
270
181
    increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);
271
272
181
    increment(tile_rows_log2, 0, 2);
273
274
181
    return 0;
275
}
276
277
197
static int FUNC(uncompressed_header)(CodedBitstreamContext *ctx, RWContext *rw,
278
                                     VP9RawFrameHeader *current)
279
{
280
197
    CodedBitstreamVP9Context *vp9 = ctx->priv_data;
281
    int err, i;
282
283
197
    f(2, frame_marker);
284
285
197
    f(1, profile_low_bit);
286
197
    f(1, profile_high_bit);
287
197
    vp9->profile = (current->profile_high_bit << 1) + current->profile_low_bit;
288
197
    if (vp9->profile == 3)
289
22
        fixed(1, reserved_zero, 0);
290
291
197
    f(1, show_existing_frame);
292
197
    if (current->show_existing_frame) {
293
16
        f(3, frame_to_show_map_idx);
294
16
        infer(header_size_in_bytes, 0);
295
16
        infer(refresh_frame_flags,  0x00);
296
16
        infer(loop_filter_level,    0);
297
16
        return 0;
298
    }
299
300
181
    f(1, frame_type);
301
181
    f(1, show_frame);
302
181
    f(1, error_resilient_mode);
303
304
181
    if (current->frame_type == VP9_KEY_FRAME) {
305
14
        CHECK(FUNC(frame_sync_code)(ctx, rw, current));
306
14
        CHECK(FUNC(color_config)(ctx, rw, current, vp9->profile));
307
14
        CHECK(FUNC(frame_size)(ctx, rw, current));
308
14
        CHECK(FUNC(render_size)(ctx, rw, current));
309
310
14
        infer(refresh_frame_flags, 0xff);
311
312
    } else {
313
167
         if (current->show_frame == 0)
314
14
             f(1, intra_only);
315
         else
316
153
             infer(intra_only, 0);
317
318
167
         if (current->error_resilient_mode == 0)
319
167
             f(2, reset_frame_context);
320
         else
321
             infer(reset_frame_context, 0);
322
323
167
         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
167
             f(8, refresh_frame_flags);
344
345
668
             for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
346
501
                 fs(3, ref_frame_idx[i], 1, i);
347
501
                 fs(1, ref_frame_sign_bias[VP9_LAST_FRAME + i],
348
                    1, VP9_LAST_FRAME + i);
349
             }
350
351
167
             CHECK(FUNC(frame_size_with_refs)(ctx, rw, current));
352
167
             f(1, allow_high_precision_mv);
353
167
             CHECK(FUNC(interpolation_filter)(ctx, rw, current));
354
         }
355
    }
356
357
181
    if (current->error_resilient_mode == 0) {
358
181
        f(1, refresh_frame_context);
359
181
        f(1, frame_parallel_decoding_mode);
360
    } else {
361
        infer(refresh_frame_context,        0);
362
        infer(frame_parallel_decoding_mode, 1);
363
    }
364
365
181
    f(2, frame_context_idx);
366
367
181
    CHECK(FUNC(loop_filter_params)(ctx, rw, current));
368
181
    CHECK(FUNC(quantization_params)(ctx, rw, current));
369
181
    CHECK(FUNC(segmentation_params)(ctx, rw, current));
370
181
    CHECK(FUNC(tile_info)(ctx, rw, current));
371
372
181
    f(16, header_size_in_bytes);
373
374
1629
    for (i = 0; i < VP9_NUM_REF_FRAMES; i++) {
375
1448
        if (current->refresh_frame_flags & (1 << i)) {
376
288
            vp9->ref[i] = (VP9ReferenceFrameState) {
377
288
                .frame_width    = vp9->frame_width,
378
288
                .frame_height   = vp9->frame_height,
379
288
                .subsampling_x  = vp9->subsampling_x,
380
288
                .subsampling_y  = vp9->subsampling_y,
381
288
                .bit_depth      = vp9->bit_depth,
382
            };
383
        }
384
    }
385
386
181
    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
181
           vp9->subsampling_x, vp9->subsampling_y,
390
181
           vp9->bit_depth, 1 << current->tile_cols_log2,
391
181
           1 << current->tile_rows_log2);
392
393
181
    return 0;
394
}
395
396
197
static int FUNC(trailing_bits)(CodedBitstreamContext *ctx, RWContext *rw)
397
{
398
    int err;
399
197
    av_unused int zero = 0;
400
653
    while (byte_alignment(rw) != 0)
401
456
        xf(1, zero_bit, zero, 0);
402
403
197
    return 0;
404
}
405
406
197
static int FUNC(frame)(CodedBitstreamContext *ctx, RWContext *rw,
407
                       VP9RawFrame *current)
408
{
409
    int err;
410
411
197
    HEADER("Frame");
412
413
197
    CHECK(FUNC(uncompressed_header)(ctx, rw, &current->header));
414
415
197
    CHECK(FUNC(trailing_bits)(ctx, rw));
416
417
197
    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
}