2 * This file is part of FFmpeg.
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.
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.
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
19 #include "libavutil/avassert.h"
22 #include "cbs_internal.h"
27 static int cbs_vp9_read_s(CodedBitstreamContext *ctx, GetBitContext *gbc,
28 int width, const char *name,
29 const int *subscripts, int32_t *write_to)
35 if (ctx->trace_enable)
36 position = get_bits_count(gbc);
38 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;
44 magnitude = get_bits(gbc, width);
45 sign = get_bits1(gbc);
46 value = sign ? -(int32_t)magnitude : magnitude;
48 if (ctx->trace_enable) {
51 for (i = 0; i < width; i++)
52 bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0';
53 bits[i] = sign ? '1' : '0';
56 ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
64 static int cbs_vp9_write_s(CodedBitstreamContext *ctx, PutBitContext *pbc,
65 int width, const char *name,
66 const int *subscripts, int32_t value)
71 if (put_bits_left(pbc) < width + 1)
72 return AVERROR(ENOSPC);
75 magnitude = sign ? -value : value;
77 if (ctx->trace_enable) {
80 for (i = 0; i < width; i++)
81 bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0';
82 bits[i] = sign ? '1' : '0';
85 ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
86 name, subscripts, bits, value);
89 put_bits(pbc, width, magnitude);
90 put_bits(pbc, 1, sign);
95 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)
103 av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
104 if (ctx->trace_enable)
105 position = get_bits_count(gbc);
107 for (i = 0, value = range_min; value < range_max;) {
108 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;
113 if (get_bits1(gbc)) {
122 if (ctx->trace_enable) {
124 ff_cbs_trace_syntax_element(ctx, position, name, NULL, bits, value);
131 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)
137 av_assert0(range_min <= range_max && range_max - range_min < 8);
138 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;
145 if (value == range_max)
146 len = range_max - range_min;
148 len = value - range_min + 1;
149 if (put_bits_left(pbc) < len)
150 return AVERROR(ENOSPC);
152 if (ctx->trace_enable) {
155 for (i = 0; i < len; i++) {
156 if (range_min + i == value)
162 ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
163 name, NULL, bits, value);
167 put_bits(pbc, len, (1 << len) - 1 - (value != range_max));
172 static int cbs_vp9_read_le(CodedBitstreamContext *ctx, GetBitContext *gbc,
173 int width, const char *name,
174 const int *subscripts, uint32_t *write_to)
179 av_assert0(width % 8 == 0);
181 if (ctx->trace_enable)
182 position = get_bits_count(gbc);
184 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;
191 for (b = 0; b < width; b += 8)
192 value |= get_bits(gbc, 8) << b;
194 if (ctx->trace_enable) {
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';
202 ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
210 static int cbs_vp9_write_le(CodedBitstreamContext *ctx, PutBitContext *pbc,
211 int width, const char *name,
212 const int *subscripts, uint32_t value)
216 av_assert0(width % 8 == 0);
218 if (put_bits_left(pbc) < width)
219 return AVERROR(ENOSPC);
221 if (ctx->trace_enable) {
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';
229 ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
230 name, subscripts, bits, value);
233 for (b = 0; b < width; b += 8)
234 put_bits(pbc, 8, value >> b & 0xff);
239 #define HEADER(name) do { \
240 ff_cbs_trace_header(ctx, name); \
243 #define CHECK(call) do { \
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)
253 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
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__)
266 #define READWRITE read
267 #define RWContext GetBitContext
269 #define xf(width, name, var, subs, ...) do { \
270 uint32_t value = 0; \
271 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
272 SUBSCRIPTS(subs, __VA_ARGS__), \
273 &value, 0, (1 << width) - 1)); \
276 #define xs(width, name, var, subs, ...) do { \
278 CHECK(cbs_vp9_read_s(ctx, rw, width, #name, \
279 SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
284 #define increment(name, min, max) do { \
285 uint32_t value = 0; \
286 CHECK(cbs_vp9_read_increment(ctx, rw, min, max, #name, &value)); \
287 current->name = value; \
290 #define fle(width, name, subs, ...) do { \
291 CHECK(cbs_vp9_read_le(ctx, rw, width, #name, \
292 SUBSCRIPTS(subs, __VA_ARGS__), ¤t->name)); \
295 #define delta_q(name) do { \
296 uint8_t delta_coded; \
298 xf(1, name.delta_coded, delta_coded, 0); \
300 xs(4, name.delta_q, delta_q, 0); \
303 current->name = delta_q; \
306 #define prob(name, subs, ...) do { \
307 uint8_t prob_coded; \
309 xf(1, name.prob_coded, prob_coded, subs, __VA_ARGS__); \
311 xf(8, name.prob, prob, subs, __VA_ARGS__); \
314 current->name = prob; \
317 #define fixed(width, name, value) do { \
318 av_unused uint32_t fixed_value = value; \
319 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
320 0, &fixed_value, value, value)); \
323 #define infer(name, value) do { \
324 current->name = value; \
327 #define byte_alignment(rw) (get_bits_count(rw) % 8)
329 #include "cbs_vp9_syntax_template.c"
342 #undef byte_alignment
346 #define READWRITE write
347 #define RWContext PutBitContext
349 #define xf(width, name, var, subs, ...) do { \
350 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
351 SUBSCRIPTS(subs, __VA_ARGS__), \
352 var, 0, (1 << width) - 1)); \
354 #define xs(width, name, var, subs, ...) do { \
355 CHECK(cbs_vp9_write_s(ctx, rw, width, #name, \
356 SUBSCRIPTS(subs, __VA_ARGS__), var)); \
359 #define increment(name, min, max) do { \
360 CHECK(cbs_vp9_write_increment(ctx, rw, min, max, #name, current->name)); \
363 #define fle(width, name, subs, ...) do { \
364 CHECK(cbs_vp9_write_le(ctx, rw, width, #name, \
365 SUBSCRIPTS(subs, __VA_ARGS__), current->name)); \
368 #define delta_q(name) do { \
369 xf(1, name.delta_coded, !!current->name, 0); \
371 xs(4, name.delta_q, current->name, 0); \
374 #define prob(name, subs, ...) do { \
375 xf(1, name.prob_coded, current->name != 255, subs, __VA_ARGS__); \
376 if (current->name != 255) \
377 xf(8, name.prob, current->name, subs, __VA_ARGS__); \
380 #define fixed(width, name, value) do { \
381 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
382 0, value, value, value)); \
385 #define infer(name, value) do { \
386 if (current->name != (value)) { \
387 av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
388 "%s does not match inferred value: " \
389 "%"PRId64", but should be %"PRId64".\n", \
390 #name, (int64_t)current->name, (int64_t)(value)); \
394 #define byte_alignment(rw) (put_bits_count(rw) % 8)
396 #include "cbs_vp9_syntax_template.c"
409 #undef byte_alignment
412 static int cbs_vp9_split_fragment(CodedBitstreamContext *ctx,
413 CodedBitstreamFragment *frag,
416 uint8_t superframe_header;
419 // Last byte in the packet.
420 superframe_header = frag->data[frag->data_size - 1];
422 if ((superframe_header & 0xe0) == 0xc0) {
423 VP9RawSuperframeIndex sfi;
425 size_t index_size, pos;
428 index_size = 2 + (((superframe_header & 0x18) >> 3) + 1) *
429 ((superframe_header & 0x07) + 1);
431 err = init_get_bits(&gbc, frag->data + frag->data_size - index_size,
436 err = cbs_vp9_read_superframe_index(ctx, &gbc, &sfi);
441 for (i = 0; i <= sfi.frames_in_superframe_minus_1; i++) {
442 if (pos + sfi.frame_sizes[i] + index_size > frag->data_size) {
443 av_log(ctx->log_ctx, AV_LOG_ERROR, "Frame %d too large "
444 "in superframe: %"PRIu32" bytes.\n",
445 i, sfi.frame_sizes[i]);
446 return AVERROR_INVALIDDATA;
449 err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
456 pos += sfi.frame_sizes[i];
458 if (pos + index_size != frag->data_size) {
459 av_log(ctx->log_ctx, AV_LOG_WARNING, "Extra padding at "
460 "end of superframe: %zu bytes.\n",
461 frag->data_size - (pos + index_size));
467 err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
468 frag->data, frag->data_size,
477 static void cbs_vp9_free_frame(void *unit, uint8_t *content)
479 VP9RawFrame *frame = (VP9RawFrame*)content;
480 av_buffer_unref(&frame->data_ref);
484 static int cbs_vp9_read_unit(CodedBitstreamContext *ctx,
485 CodedBitstreamUnit *unit)
491 err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
495 err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*frame),
496 &cbs_vp9_free_frame);
499 frame = unit->content;
501 err = cbs_vp9_read_frame(ctx, &gbc, frame);
505 pos = get_bits_count(&gbc);
506 av_assert0(pos % 8 == 0);
508 av_assert0(pos <= unit->data_size);
510 if (pos == unit->data_size) {
511 // No data (e.g. a show-existing-frame frame).
513 frame->data_ref = av_buffer_ref(unit->data_ref);
514 if (!frame->data_ref)
515 return AVERROR(ENOMEM);
517 frame->data = unit->data + pos;
518 frame->data_size = unit->data_size - pos;
524 static int cbs_vp9_write_unit(CodedBitstreamContext *ctx,
525 CodedBitstreamUnit *unit)
527 CodedBitstreamVP9Context *priv = ctx->priv_data;
528 VP9RawFrame *frame = unit->content;
532 if (!priv->write_buffer) {
533 // Initial write buffer size is 1MB.
534 priv->write_buffer_size = 1024 * 1024;
536 reallocate_and_try_again:
537 err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
539 av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
540 "sufficiently large write buffer (last attempt "
541 "%zu bytes).\n", priv->write_buffer_size);
546 init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
548 err = cbs_vp9_write_frame(ctx, &pbc, frame);
549 if (err == AVERROR(ENOSPC)) {
550 priv->write_buffer_size *= 2;
551 goto reallocate_and_try_again;
556 // Frame must be byte-aligned.
557 av_assert0(put_bits_count(&pbc) % 8 == 0);
559 unit->data_size = put_bits_count(&pbc) / 8;
560 unit->data_bit_padding = 0;
561 flush_put_bits(&pbc);
564 if (unit->data_size + frame->data_size >
565 priv->write_buffer_size) {
566 priv->write_buffer_size *= 2;
567 goto reallocate_and_try_again;
570 memcpy(priv->write_buffer + unit->data_size,
571 frame->data, frame->data_size);
572 unit->data_size += frame->data_size;
575 err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);
579 memcpy(unit->data, priv->write_buffer, unit->data_size);
584 static int cbs_vp9_assemble_fragment(CodedBitstreamContext *ctx,
585 CodedBitstreamFragment *frag)
589 if (frag->nb_units == 1) {
590 // Output is just the content of the single frame.
592 CodedBitstreamUnit *frame = &frag->units[0];
594 frag->data_ref = av_buffer_ref(frame->data_ref);
596 return AVERROR(ENOMEM);
598 frag->data = frame->data;
599 frag->data_size = frame->data_size;
602 // Build superframe out of frames.
604 VP9RawSuperframeIndex sfi;
608 size_t size, max, pos;
611 if (frag->nb_units > 8) {
612 av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many frames to "
613 "make superframe: %d.\n", frag->nb_units);
614 return AVERROR(EINVAL);
618 for (i = 0; i < frag->nb_units; i++)
619 if (max < frag->units[i].data_size)
620 max = frag->units[i].data_size;
625 size_len = av_log2(max) / 8 + 1;
626 av_assert0(size_len <= 4);
628 sfi.superframe_marker = VP9_SUPERFRAME_MARKER;
629 sfi.bytes_per_framesize_minus_1 = size_len - 1;
630 sfi.frames_in_superframe_minus_1 = frag->nb_units - 1;
633 for (i = 0; i < frag->nb_units; i++) {
634 size += size_len + frag->units[i].data_size;
635 sfi.frame_sizes[i] = frag->units[i].data_size;
638 ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
640 return AVERROR(ENOMEM);
642 memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
645 for (i = 0; i < frag->nb_units; i++) {
646 av_assert0(size - pos > frag->units[i].data_size);
647 memcpy(data + pos, frag->units[i].data,
648 frag->units[i].data_size);
649 pos += frag->units[i].data_size;
651 av_assert0(size - pos == 2 + frag->nb_units * size_len);
653 init_put_bits(&pbc, data + pos, size - pos);
655 err = cbs_vp9_write_superframe_index(ctx, &pbc, &sfi);
657 av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write "
658 "superframe index.\n");
659 av_buffer_unref(&ref);
663 av_assert0(put_bits_left(&pbc) == 0);
664 flush_put_bits(&pbc);
666 frag->data_ref = ref;
668 frag->data_size = size;
674 static void cbs_vp9_close(CodedBitstreamContext *ctx)
676 CodedBitstreamVP9Context *priv = ctx->priv_data;
678 av_freep(&priv->write_buffer);
681 const CodedBitstreamType ff_cbs_type_vp9 = {
682 .codec_id = AV_CODEC_ID_VP9,
684 .priv_data_size = sizeof(CodedBitstreamVP9Context),
686 .split_fragment = &cbs_vp9_split_fragment,
687 .read_unit = &cbs_vp9_read_unit,
688 .write_unit = &cbs_vp9_write_unit,
689 .assemble_fragment = &cbs_vp9_assemble_fragment,
691 .close = &cbs_vp9_close,