FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/cbs_vp9.c
Date: 2021-09-16 08:47:15
Exec Total Coverage
Lines: 153 222 68.9%
Branches: 83 160 51.9%

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 #include "libavutil/avassert.h"
20
21 #include "cbs.h"
22 #include "cbs_internal.h"
23 #include "cbs_vp9.h"
24 #include "internal.h"
25
26
27 50 static int cbs_vp9_read_s(CodedBitstreamContext *ctx, GetBitContext *gbc,
28 int width, const char *name,
29 const int *subscripts, int32_t *write_to)
30 {
31 uint32_t magnitude;
32 int position, sign;
33 int32_t value;
34
35
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
50 if (ctx->trace_enable)
36 position = get_bits_count(gbc);
37
38
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
50 if (get_bits_left(gbc) < width + 1) {
39 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid signed value at "
40 "%s: bitstream ended.\n", name);
41 return AVERROR_INVALIDDATA;
42 }
43
44 50 magnitude = get_bits(gbc, width);
45 50 sign = get_bits1(gbc);
46
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 18 times.
50 value = sign ? -(int32_t)magnitude : magnitude;
47
48
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
50 if (ctx->trace_enable) {
49 char bits[33];
50 int i;
51 for (i = 0; i < width; i++)
52 bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0';
53 bits[i] = sign ? '1' : '0';
54 bits[i + 1] = 0;
55
56 ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
57 bits, value);
58 }
59
60 50 *write_to = value;
61 50 return 0;
62 }
63
64 50 static int cbs_vp9_write_s(CodedBitstreamContext *ctx, PutBitContext *pbc,
65 int width, const char *name,
66 const int *subscripts, int32_t value)
67 {
68 uint32_t magnitude;
69 int sign;
70
71
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
50 if (put_bits_left(pbc) < width + 1)
72 return AVERROR(ENOSPC);
73
74 50 sign = value < 0;
75
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 18 times.
50 magnitude = sign ? -value : value;
76
77
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
50 if (ctx->trace_enable) {
78 char bits[33];
79 int i;
80 for (i = 0; i < width; i++)
81 bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0';
82 bits[i] = sign ? '1' : '0';
83 bits[i + 1] = 0;
84
85 ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
86 name, subscripts, bits, value);
87 }
88
89 50 put_bits(pbc, width, magnitude);
90 50 put_bits(pbc, 1, sign);
91
92 50 return 0;
93 }
94
95 362 static int cbs_vp9_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc,
96 uint32_t range_min, uint32_t range_max,
97 const char *name, uint32_t *write_to)
98 {
99 uint32_t value;
100 int position, i;
101 char bits[8];
102
103
2/4
✓ Branch 0 taken 362 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 362 times.
362 av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 362 times.
362 if (ctx->trace_enable)
105 position = get_bits_count(gbc);
106
107
2/2
✓ Branch 0 taken 187 times.
✓ Branch 1 taken 179 times.
366 for (i = 0, value = range_min; value < range_max;) {
108
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 187 times.
187 if (get_bits_left(gbc) < 1) {
109 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid increment value at "
110 "%s: bitstream ended.\n", name);
111 return AVERROR_INVALIDDATA;
112 }
113
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 183 times.
187 if (get_bits1(gbc)) {
114 4 bits[i++] = '1';
115 4 ++value;
116 } else {
117 183 bits[i++] = '0';
118 183 break;
119 }
120 }
121
122
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 362 times.
362 if (ctx->trace_enable) {
123 bits[i] = 0;
124 ff_cbs_trace_syntax_element(ctx, position, name, NULL, bits, value);
125 }
126
127 362 *write_to = value;
128 362 return 0;
129 }
130
131 362 static int cbs_vp9_write_increment(CodedBitstreamContext *ctx, PutBitContext *pbc,
132 uint32_t range_min, uint32_t range_max,
133 const char *name, uint32_t value)
134 {
135 int len;
136
137
2/4
✓ Branch 0 taken 362 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 362 times.
362 av_assert0(range_min <= range_max && range_max - range_min < 8);
138
2/4
✓ Branch 0 taken 362 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 362 times.
362 if (value < range_min || value > range_max) {
139 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
140 "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
141 name, value, range_min, range_max);
142 return AVERROR_INVALIDDATA;
143 }
144
145
2/2
✓ Branch 0 taken 179 times.
✓ Branch 1 taken 183 times.
362 if (value == range_max)
146 179 len = range_max - range_min;
147 else
148 183 len = value - range_min + 1;
149
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 362 times.
362 if (put_bits_left(pbc) < len)
150 return AVERROR(ENOSPC);
151
152
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 362 times.
362 if (ctx->trace_enable) {
153 char bits[8];
154 int i;
155 for (i = 0; i < len; i++) {
156 if (range_min + i == value)
157 bits[i] = '0';
158 else
159 bits[i] = '1';
160 }
161 bits[i] = 0;
162 ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
163 name, NULL, bits, value);
164 }
165
166
2/2
✓ Branch 0 taken 183 times.
✓ Branch 1 taken 179 times.
362 if (len > 0)
167 183 put_bits(pbc, len, (1 << len) - 1 - (value != range_max));
168
169 362 return 0;
170 }
171
172 27 static int cbs_vp9_read_le(CodedBitstreamContext *ctx, GetBitContext *gbc,
173 int width, const char *name,
174 const int *subscripts, uint32_t *write_to)
175 {
176 uint32_t value;
177 int position, b;
178
179
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
27 av_assert0(width % 8 == 0);
180
181
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
27 if (ctx->trace_enable)
182 position = get_bits_count(gbc);
183
184
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 27 times.
27 if (get_bits_left(gbc) < width) {
185 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid le value at "
186 "%s: bitstream ended.\n", name);
187 return AVERROR_INVALIDDATA;
188 }
189
190 27 value = 0;
191
2/2
✓ Branch 0 taken 54 times.
✓ Branch 1 taken 27 times.
81 for (b = 0; b < width; b += 8)
192 54 value |= get_bits(gbc, 8) << b;
193
194
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
27 if (ctx->trace_enable) {
195 char bits[33];
196 int i;
197 for (b = 0; b < width; b += 8)
198 for (i = 0; i < 8; i++)
199 bits[b + i] = value >> (b + i) & 1 ? '1' : '0';
200 bits[b] = 0;
201
202 ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
203 bits, value);
204 }
205
206 27 *write_to = value;
207 27 return 0;
208 }
209
210 27 static int cbs_vp9_write_le(CodedBitstreamContext *ctx, PutBitContext *pbc,
211 int width, const char *name,
212 const int *subscripts, uint32_t value)
213 {
214 int b;
215
216
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
27 av_assert0(width % 8 == 0);
217
218
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 27 times.
27 if (put_bits_left(pbc) < width)
219 return AVERROR(ENOSPC);
220
221
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
27 if (ctx->trace_enable) {
222 char bits[33];
223 int i;
224 for (b = 0; b < width; b += 8)
225 for (i = 0; i < 8; i++)
226 bits[b + i] = value >> (b + i) & 1 ? '1' : '0';
227 bits[b] = 0;
228
229 ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
230 name, subscripts, bits, value);
231 }
232
233
2/2
✓ Branch 0 taken 54 times.
✓ Branch 1 taken 27 times.
81 for (b = 0; b < width; b += 8)
234 54 put_bits(pbc, 8, value >> b & 0xff);
235
236 27 return 0;
237 }
238
239 #define HEADER(name) do { \
240 ff_cbs_trace_header(ctx, name); \
241 } while (0)
242
243 #define CHECK(call) do { \
244 err = (call); \
245 if (err < 0) \
246 return err; \
247 } while (0)
248
249 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
250 #define FUNC_VP9(rw, name) FUNC_NAME(rw, vp9, name)
251 #define FUNC(name) FUNC_VP9(READWRITE, name)
252
253 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
254
255 #define f(width, name) \
256 xf(width, name, current->name, 0, )
257 #define s(width, name) \
258 xs(width, name, current->name, 0, )
259 #define fs(width, name, subs, ...) \
260 xf(width, name, current->name, subs, __VA_ARGS__)
261 #define ss(width, name, subs, ...) \
262 xs(width, name, current->name, subs, __VA_ARGS__)
263
264 #define READ
265 #define READWRITE read
266 #define RWContext GetBitContext
267
268 #define xf(width, name, var, subs, ...) do { \
269 uint32_t value; \
270 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
271 SUBSCRIPTS(subs, __VA_ARGS__), \
272 &value, 0, (1 << width) - 1)); \
273 var = value; \
274 } while (0)
275 #define xs(width, name, var, subs, ...) do { \
276 int32_t value; \
277 CHECK(cbs_vp9_read_s(ctx, rw, width, #name, \
278 SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
279 var = value; \
280 } while (0)
281
282
283 #define increment(name, min, max) do { \
284 uint32_t value; \
285 CHECK(cbs_vp9_read_increment(ctx, rw, min, max, #name, &value)); \
286 current->name = value; \
287 } while (0)
288
289 #define fle(width, name, subs, ...) do { \
290 CHECK(cbs_vp9_read_le(ctx, rw, width, #name, \
291 SUBSCRIPTS(subs, __VA_ARGS__), &current->name)); \
292 } while (0)
293
294 #define delta_q(name) do { \
295 uint8_t delta_coded; \
296 int8_t delta_q; \
297 xf(1, name.delta_coded, delta_coded, 0, ); \
298 if (delta_coded) \
299 xs(4, name.delta_q, delta_q, 0, ); \
300 else \
301 delta_q = 0; \
302 current->name = delta_q; \
303 } while (0)
304
305 #define prob(name, subs, ...) do { \
306 uint8_t prob_coded; \
307 uint8_t prob; \
308 xf(1, name.prob_coded, prob_coded, subs, __VA_ARGS__); \
309 if (prob_coded) \
310 xf(8, name.prob, prob, subs, __VA_ARGS__); \
311 else \
312 prob = 255; \
313 current->name = prob; \
314 } while (0)
315
316 #define fixed(width, name, value) do { \
317 av_unused uint32_t fixed_value; \
318 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
319 0, &fixed_value, value, value)); \
320 } while (0)
321
322 #define infer(name, value) do { \
323 current->name = value; \
324 } while (0)
325
326 #define byte_alignment(rw) (get_bits_count(rw) % 8)
327
328 #include "cbs_vp9_syntax_template.c"
329
330 #undef READ
331 #undef READWRITE
332 #undef RWContext
333 #undef xf
334 #undef xs
335 #undef increment
336 #undef fle
337 #undef delta_q
338 #undef prob
339 #undef fixed
340 #undef infer
341 #undef byte_alignment
342
343
344 #define WRITE
345 #define READWRITE write
346 #define RWContext PutBitContext
347
348 #define xf(width, name, var, subs, ...) do { \
349 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
350 SUBSCRIPTS(subs, __VA_ARGS__), \
351 var, 0, (1 << width) - 1)); \
352 } while (0)
353 #define xs(width, name, var, subs, ...) do { \
354 CHECK(cbs_vp9_write_s(ctx, rw, width, #name, \
355 SUBSCRIPTS(subs, __VA_ARGS__), var)); \
356 } while (0)
357
358 #define increment(name, min, max) do { \
359 CHECK(cbs_vp9_write_increment(ctx, rw, min, max, #name, current->name)); \
360 } while (0)
361
362 #define fle(width, name, subs, ...) do { \
363 CHECK(cbs_vp9_write_le(ctx, rw, width, #name, \
364 SUBSCRIPTS(subs, __VA_ARGS__), current->name)); \
365 } while (0)
366
367 #define delta_q(name) do { \
368 xf(1, name.delta_coded, !!current->name, 0, ); \
369 if (current->name) \
370 xs(4, name.delta_q, current->name, 0, ); \
371 } while (0)
372
373 #define prob(name, subs, ...) do { \
374 xf(1, name.prob_coded, current->name != 255, subs, __VA_ARGS__); \
375 if (current->name != 255) \
376 xf(8, name.prob, current->name, subs, __VA_ARGS__); \
377 } while (0)
378
379 #define fixed(width, name, value) do { \
380 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
381 0, value, value, value)); \
382 } while (0)
383
384 #define infer(name, value) do { \
385 if (current->name != (value)) { \
386 av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
387 "%s does not match inferred value: " \
388 "%"PRId64", but should be %"PRId64".\n", \
389 #name, (int64_t)current->name, (int64_t)(value)); \
390 } \
391 } while (0)
392
393 #define byte_alignment(rw) (put_bits_count(rw) % 8)
394
395 #include "cbs_vp9_syntax_template.c"
396
397 #undef WRITE
398 #undef READWRITE
399 #undef RWContext
400 #undef xf
401 #undef xs
402 #undef increment
403 #undef fle
404 #undef delta_q
405 #undef prob
406 #undef fixed
407 #undef infer
408 #undef byte_alignment
409
410
411 183 static int cbs_vp9_split_fragment(CodedBitstreamContext *ctx,
412 CodedBitstreamFragment *frag,
413 int header)
414 {
415 uint8_t superframe_header;
416 int err;
417
418
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
183 if (frag->data_size == 0)
419 return AVERROR_INVALIDDATA;
420
421 // Last byte in the packet.
422 183 superframe_header = frag->data[frag->data_size - 1];
423
424
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 170 times.
183 if ((superframe_header & 0xe0) == 0xc0) {
425 VP9RawSuperframeIndex sfi;
426 GetBitContext gbc;
427 size_t index_size, pos;
428 int i;
429
430 13 index_size = 2 + (((superframe_header & 0x18) >> 3) + 1) *
431 13 ((superframe_header & 0x07) + 1);
432
433
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (index_size > frag->data_size)
434 return AVERROR_INVALIDDATA;
435
436 13 err = init_get_bits(&gbc, frag->data + frag->data_size - index_size,
437 8 * index_size);
438
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (err < 0)
439 return err;
440
441 13 err = cbs_vp9_read_superframe_index(ctx, &gbc, &sfi);
442
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (err < 0)
443 return err;
444
445 13 pos = 0;
446
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 13 times.
40 for (i = 0; i <= sfi.frames_in_superframe_minus_1; i++) {
447
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
27 if (pos + sfi.frame_sizes[i] + index_size > frag->data_size) {
448 av_log(ctx->log_ctx, AV_LOG_ERROR, "Frame %d too large "
449 "in superframe: %"PRIu32" bytes.\n",
450 i, sfi.frame_sizes[i]);
451 return AVERROR_INVALIDDATA;
452 }
453
454 27 err = ff_cbs_insert_unit_data(frag, -1, 0,
455 27 frag->data + pos,
456 27 sfi.frame_sizes[i],
457 frag->data_ref);
458
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
27 if (err < 0)
459 return err;
460
461 27 pos += sfi.frame_sizes[i];
462 }
463
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (pos + index_size != frag->data_size) {
464 av_log(ctx->log_ctx, AV_LOG_WARNING, "Extra padding at "
465 "end of superframe: %"SIZE_SPECIFIER" bytes.\n",
466 frag->data_size - (pos + index_size));
467 }
468
469 13 return 0;
470
471 } else {
472 170 err = ff_cbs_insert_unit_data(frag, -1, 0,
473 frag->data, frag->data_size,
474 frag->data_ref);
475
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170 times.
170 if (err < 0)
476 return err;
477 }
478
479 170 return 0;
480 }
481
482 197 static int cbs_vp9_read_unit(CodedBitstreamContext *ctx,
483 CodedBitstreamUnit *unit)
484 {
485 VP9RawFrame *frame;
486 GetBitContext gbc;
487 int err, pos;
488
489 197 err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
490
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
197 if (err < 0)
491 return err;
492
493 197 err = ff_cbs_alloc_unit_content2(ctx, unit);
494
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
197 if (err < 0)
495 return err;
496 197 frame = unit->content;
497
498 197 err = cbs_vp9_read_frame(ctx, &gbc, frame);
499
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
197 if (err < 0)
500 return err;
501
502 197 pos = get_bits_count(&gbc);
503
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
197 av_assert0(pos % 8 == 0);
504 197 pos /= 8;
505
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
197 av_assert0(pos <= unit->data_size);
506
507
2/2
✓ Branch 0 taken 181 times.
✓ Branch 1 taken 16 times.
197 if (pos == unit->data_size) {
508 // No data (e.g. a show-existing-frame frame).
509 } else {
510 181 frame->data_ref = av_buffer_ref(unit->data_ref);
511
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 181 times.
181 if (!frame->data_ref)
512 return AVERROR(ENOMEM);
513
514 181 frame->data = unit->data + pos;
515 181 frame->data_size = unit->data_size - pos;
516 }
517
518 197 return 0;
519 }
520
521 197 static int cbs_vp9_write_unit(CodedBitstreamContext *ctx,
522 CodedBitstreamUnit *unit,
523 PutBitContext *pbc)
524 {
525 197 VP9RawFrame *frame = unit->content;
526 int err;
527
528 197 err = cbs_vp9_write_frame(ctx, pbc, frame);
529
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
197 if (err < 0)
530 return err;
531
532 // Frame must be byte-aligned.
533
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 197 times.
197 av_assert0(put_bits_count(pbc) % 8 == 0);
534
535
2/2
✓ Branch 0 taken 181 times.
✓ Branch 1 taken 16 times.
197 if (frame->data) {
536
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 181 times.
181 if (frame->data_size > put_bits_left(pbc) / 8)
537 return AVERROR(ENOSPC);
538
539 181 flush_put_bits(pbc);
540 181 memcpy(put_bits_ptr(pbc), frame->data, frame->data_size);
541 181 skip_put_bytes(pbc, frame->data_size);
542 }
543
544 197 return 0;
545 }
546
547 183 static int cbs_vp9_assemble_fragment(CodedBitstreamContext *ctx,
548 CodedBitstreamFragment *frag)
549 {
550 int err;
551
552
2/2
✓ Branch 0 taken 170 times.
✓ Branch 1 taken 13 times.
183 if (frag->nb_units == 1) {
553 // Output is just the content of the single frame.
554
555 170 CodedBitstreamUnit *frame = &frag->units[0];
556
557 170 frag->data_ref = av_buffer_ref(frame->data_ref);
558
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 170 times.
170 if (!frag->data_ref)
559 return AVERROR(ENOMEM);
560
561 170 frag->data = frame->data;
562 170 frag->data_size = frame->data_size;
563
564 } else {
565 // Build superframe out of frames.
566
567 VP9RawSuperframeIndex sfi;
568 PutBitContext pbc;
569 AVBufferRef *ref;
570 uint8_t *data;
571 size_t size, max, pos;
572 int i, size_len;
573
574
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (frag->nb_units > 8) {
575 av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many frames to "
576 "make superframe: %d.\n", frag->nb_units);
577 return AVERROR(EINVAL);
578 }
579
580 13 max = 0;
581
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 13 times.
40 for (i = 0; i < frag->nb_units; i++)
582
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 13 times.
27 if (max < frag->units[i].data_size)
583 14 max = frag->units[i].data_size;
584
585
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (max < 2)
586 size_len = 1;
587 else
588 13 size_len = av_log2(max) / 8 + 1;
589
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 av_assert0(size_len <= 4);
590
591 13 sfi.superframe_marker = VP9_SUPERFRAME_MARKER;
592 13 sfi.bytes_per_framesize_minus_1 = size_len - 1;
593 13 sfi.frames_in_superframe_minus_1 = frag->nb_units - 1;
594
595 13 size = 2;
596
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 13 times.
40 for (i = 0; i < frag->nb_units; i++) {
597 27 size += size_len + frag->units[i].data_size;
598 27 sfi.frame_sizes[i] = frag->units[i].data_size;
599 }
600
601 13 ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
602
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (!ref)
603 return AVERROR(ENOMEM);
604 13 data = ref->data;
605 13 memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
606
607 13 pos = 0;
608
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 13 times.
40 for (i = 0; i < frag->nb_units; i++) {
609
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
27 av_assert0(size - pos > frag->units[i].data_size);
610 27 memcpy(data + pos, frag->units[i].data,
611 27 frag->units[i].data_size);
612 27 pos += frag->units[i].data_size;
613 }
614
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 av_assert0(size - pos == 2 + frag->nb_units * size_len);
615
616 13 init_put_bits(&pbc, data + pos, size - pos);
617
618 13 err = cbs_vp9_write_superframe_index(ctx, &pbc, &sfi);
619
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (err < 0) {
620 av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write "
621 "superframe index.\n");
622 av_buffer_unref(&ref);
623 return err;
624 }
625
626
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
13 av_assert0(put_bits_left(&pbc) == 0);
627 13 flush_put_bits(&pbc);
628
629 13 frag->data_ref = ref;
630 13 frag->data = data;
631 13 frag->data_size = size;
632 }
633
634 183 return 0;
635 }
636
637 static void cbs_vp9_flush(CodedBitstreamContext *ctx)
638 {
639 CodedBitstreamVP9Context *vp9 = ctx->priv_data;
640
641 memset(vp9->ref, 0, sizeof(vp9->ref));
642 }
643
644 static const CodedBitstreamUnitTypeDescriptor cbs_vp9_unit_types[] = {
645 CBS_UNIT_TYPE_INTERNAL_REF(0, VP9RawFrame, data),
646 CBS_UNIT_TYPE_END_OF_LIST
647 };
648
649 const CodedBitstreamType ff_cbs_type_vp9 = {
650 .codec_id = AV_CODEC_ID_VP9,
651
652 .priv_data_size = sizeof(CodedBitstreamVP9Context),
653
654 .unit_types = cbs_vp9_unit_types,
655
656 .split_fragment = &cbs_vp9_split_fragment,
657 .read_unit = &cbs_vp9_read_unit,
658 .write_unit = &cbs_vp9_write_unit,
659
660 .flush = &cbs_vp9_flush,
661
662 .assemble_fragment = &cbs_vp9_assemble_fragment,
663 };
664