This commit adds support for VP8 bitstream read methods to the cbs codec. This enables the trace_headers bitstream filter to support VP8, in addition to AV1, H.264, H.265, and VP9. This can be useful for debugging VP8 stream issues. The CBS VP8 implements a simple VP8 boolean decoder using GetBitContext to read the bitstream. Only the read methods `read_unit` and `split_fragment` are implemented. The write methods `write_unit` and `assemble_fragment` return the error code AVERROR_PATCHWELCOME. This is because CBS VP8 write is unlikely to be used by any applications at the moment. The write methods can be added later if there is a real need for them. TESTS: ffmpeg -i fate-suite/vp8/frame_size_change.webm -vcodec copy -bsf:v trace_headers -f null -
Showing the changes to libavcodec (6 of 7 files). Show all
Unified · Split
| @@ -81,6 +81,7 @@ OBJS-$(CONFIG_CBS_H265) += cbs_h2645.o cbs_sei.o h2645_parse.o · 80 unmodified lines | ||
| 81 | 81 | OBJS-$(CONFIG_CBS_H266) += cbs_h2645.o cbs_sei.o h2645_parse.o |
| 82 | 82 | OBJS-$(CONFIG_CBS_JPEG) += cbs_jpeg.o |
| 83 | 83 | OBJS-$(CONFIG_CBS_MPEG2) += cbs_mpeg2.o |
| 84 | +OBJS-$(CONFIG_CBS_VP8) += cbs_vp8.o vp8data.o | |
| 84 | 85 | OBJS-$(CONFIG_CBS_VP9) += cbs_vp9.o |
| 85 | 86 | OBJS-$(CONFIG_CRYSTALHD) += crystalhd.o |
| 86 | 87 | OBJS-$(CONFIG_DEFLATE_WRAPPER) += zlib_wrapper.o |
| @@ -50,6 +50,9 @@ static const CodedBitstreamType *const cbs_type_table[] = { · 49 unmodified lines | ||
| 50 | 50 | #if CONFIG_CBS_MPEG2 |
| 51 | 51 | &ff_cbs_type_mpeg2, |
| 52 | 52 | #endif |
| 53 | +#if CONFIG_CBS_VP8 | |
| 54 | + &ff_cbs_type_vp8, | |
| 55 | +#endif | |
| 53 | 56 | #if CONFIG_CBS_VP9 |
| 54 | 57 | &ff_cbs_type_vp9, |
| 55 | 58 | #endif |
| @@ -74,6 +77,9 @@ const enum AVCodecID ff_cbs_all_codec_ids[] = { · 18 unmodified lines | ||
| 74 | 77 | #if CONFIG_CBS_MPEG2 |
| 75 | 78 | AV_CODEC_ID_MPEG2VIDEO, |
| 76 | 79 | #endif |
| 80 | +#if CONFIG_CBS_VP8 | |
| 81 | + AV_CODEC_ID_VP8, | |
| 82 | +#endif | |
| 77 | 83 | #if CONFIG_CBS_VP9 |
| 78 | 84 | AV_CODEC_ID_VP9, |
| 79 | 85 | #endif |
| @@ -341,6 +341,7 @@ extern const CodedBitstreamType ff_cbs_type_h265; · 340 unmodified lines | ||
| 341 | 341 | extern const CodedBitstreamType ff_cbs_type_h266; |
| 342 | 342 | extern const CodedBitstreamType ff_cbs_type_jpeg; |
| 343 | 343 | extern const CodedBitstreamType ff_cbs_type_mpeg2; |
| 344 | +extern const CodedBitstreamType ff_cbs_type_vp8; | |
| 344 | 345 | extern const CodedBitstreamType ff_cbs_type_vp9; |
| 345 | 346 | |
| 346 | 347 | |
| @@ -0,0 +1,380 @@ | ||
| 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_vp8.h" | |
| 24 | + | |
| 25 | +#include <stdbool.h> | |
| 26 | + | |
| 27 | +#define DEFAULT_PROB 0x80 | |
| 28 | + | |
| 29 | +// The probability table is defined in 'vp8data.c'. | |
| 30 | +extern const uint8_t ff_vp8_token_update_probs[4][8][3][11]; | |
| 31 | + | |
| 32 | +// Implements VP8 boolean decoder using GetBitContext to read the bitstream. | |
| 33 | +typedef struct CBSVP8BoolDecoder { | |
| 34 | + GetBitContext *gbc; | |
| 35 | + | |
| 36 | + uint8_t value; | |
| 37 | + uint8_t range; | |
| 38 | + | |
| 39 | + uint8_t count; // Store the number of bits in the `value` buffer. | |
| 40 | + | |
| 41 | +} CBSVP8BoolDecoder; | |
| 42 | + | |
| 43 | +static int cbs_vp8_bool_decoder_init(CBSVP8BoolDecoder *decoder, GetBitContext *gbc) | |
| 44 | +{ | |
| 45 | + av_assert0(decoder); | |
| 46 | + av_assert0(gbc); | |
| 47 | + | |
| 48 | + decoder->gbc = gbc; | |
| 49 | + decoder->value = 0; | |
| 50 | + decoder->range = 255; | |
| 51 | + | |
| 52 | + decoder->count = 0; | |
| 53 | + | |
| 54 | + return 0; | |
| 55 | +} | |
| 56 | + | |
| 57 | +static bool cbs_vp8_bool_decoder_fill_value(CBSVP8BoolDecoder *decoder) | |
| 58 | +{ | |
| 59 | + int bits = 8 - decoder->count; | |
| 60 | + | |
| 61 | + av_assert0(decoder->count <= 8); | |
| 62 | + if (decoder->count == 8) { | |
| 63 | + return true; | |
| 64 | + } | |
| 65 | + | |
| 66 | + if (get_bits_left(decoder->gbc) >= bits) { | |
| 67 | + decoder->value |= get_bits(decoder->gbc, bits); | |
| 68 | + decoder->count += bits; | |
| 69 | + } | |
| 70 | + | |
| 71 | + return (decoder->count == 8); | |
| 72 | +} | |
| 73 | + | |
| 74 | +static int cbs_vp8_bool_decoder_read_bool(CBSVP8BoolDecoder *decoder, | |
| 75 | + const uint8_t prob, uint8_t *output) | |
| 76 | +{ | |
| 77 | + uint8_t split = 1 + (((decoder->range - 1) * prob) >> 8); | |
| 78 | + | |
| 79 | + if (!cbs_vp8_bool_decoder_fill_value(decoder)) { | |
| 80 | + return AVERROR_INVALIDDATA; | |
| 81 | + } | |
| 82 | + | |
| 83 | + av_assert0(decoder->count == 8); | |
| 84 | + if (decoder->value >= split) { | |
| 85 | + *output = 1; | |
| 86 | + decoder->range -= split; | |
| 87 | + decoder->value -= split; | |
| 88 | + } else { | |
| 89 | + *output = 0; | |
| 90 | + decoder->range = split; | |
| 91 | + } | |
| 92 | + | |
| 93 | + while (decoder->range < 128) { | |
| 94 | + decoder->value <<= 1; | |
| 95 | + decoder->range <<= 1; | |
| 96 | + --decoder->count; | |
| 97 | + } | |
| 98 | + | |
| 99 | + return 0; | |
| 100 | +} | |
| 101 | + | |
| 102 | +static int cbs_vp8_bool_decoder_read_literal(CBSVP8BoolDecoder *decoder, | |
| 103 | + const uint8_t prob, | |
| 104 | + uint32_t num_bits, | |
| 105 | + uint32_t *output) | |
| 106 | +{ | |
| 107 | + int ret = 0; | |
| 108 | + | |
| 109 | + av_assert0(num_bits <= 32); | |
| 110 | + | |
| 111 | + *output = 0; | |
| 112 | + for (; num_bits > 0; --num_bits) { | |
| 113 | + uint8_t bit_output = 0; | |
| 114 | + if ((ret = cbs_vp8_bool_decoder_read_bool(decoder, prob, | |
| 115 | + &bit_output)) != 0) { | |
| 116 | + return ret; | |
| 117 | + } | |
| 118 | + | |
| 119 | + *output = (*output << 1) | bit_output; | |
| 120 | + } | |
| 121 | + | |
| 122 | + return 0; | |
| 123 | +} | |
| 124 | + | |
| 125 | +static int cbs_vp8_bool_decoder_read_unsigned( | |
| 126 | + CodedBitstreamContext *ctx, CBSVP8BoolDecoder *bool_decoder, int width, | |
| 127 | + uint8_t prob, const char *name, const int *subscripts, uint32_t *write_to, | |
| 128 | + bool trace_enable) | |
| 129 | +{ | |
| 130 | + int ret = 0; | |
| 131 | + GetBitContext *gbc = bool_decoder->gbc; | |
| 132 | + uint32_t value; | |
| 133 | + | |
| 134 | + CBS_TRACE_READ_START(); | |
| 135 | + | |
| 136 | + av_assert0(width >= 0 && width <= 8); | |
| 137 | + | |
| 138 | + ret = cbs_vp8_bool_decoder_read_literal(bool_decoder, prob, width, &value); | |
| 139 | + if (ret != 0) { | |
| 140 | + return ret; | |
| 141 | + } | |
| 142 | + | |
| 143 | + if (trace_enable) { | |
| 144 | + CBS_TRACE_READ_END(); | |
| 145 | + } | |
| 146 | + | |
| 147 | + *write_to = value; | |
| 148 | + return 0; | |
| 149 | +} | |
| 150 | + | |
| 151 | +static int cbs_vp8_bool_decoder_read_signed( | |
| 152 | + CodedBitstreamContext *ctx, CBSVP8BoolDecoder *bool_decoder, int width, | |
| 153 | + uint8_t prob, const char *name, const int *subscripts, int32_t *write_to) | |
| 154 | +{ | |
| 155 | + int ret = 0; | |
| 156 | + GetBitContext *gbc = bool_decoder->gbc; | |
| 157 | + int32_t value; | |
| 158 | + uint8_t sign = 0; | |
| 159 | + | |
| 160 | + CBS_TRACE_READ_START(); | |
| 161 | + | |
| 162 | + av_assert0(width >= 0 && width <= 8); | |
| 163 | + | |
| 164 | + ret = cbs_vp8_bool_decoder_read_literal(bool_decoder, prob, width, &value); | |
| 165 | + if (ret != 0) { | |
| 166 | + return ret; | |
| 167 | + } | |
| 168 | + | |
| 169 | + ret = cbs_vp8_bool_decoder_read_bool(bool_decoder, prob, &sign); | |
| 170 | + if (ret != 0) { | |
| 171 | + return ret; | |
| 172 | + } | |
| 173 | + | |
| 174 | + if (sign) { | |
| 175 | + value = -value; | |
| 176 | + } | |
| 177 | + | |
| 178 | + CBS_TRACE_READ_END(); | |
| 179 | + | |
| 180 | + *write_to = value; | |
| 181 | + return 0; | |
| 182 | +} | |
| 183 | + | |
| 184 | +static int cbs_vp8_read_unsigned_le(CodedBitstreamContext *ctx, GetBitContext *gbc, | |
| 185 | + int width, const char *name, | |
| 186 | + const int *subscripts, uint32_t *write_to) | |
| 187 | +{ | |
| 188 | + int32_t value; | |
| 189 | + | |
| 190 | + CBS_TRACE_READ_START(); | |
| 191 | + | |
| 192 | + av_assert0(width > 0 && width <= 24); | |
| 193 | + | |
| 194 | + if (get_bits_left(gbc) < width) { | |
| 195 | + av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value: bitstream ended.\n"); | |
| 196 | + return AVERROR_INVALIDDATA; | |
| 197 | + } | |
| 198 | + | |
| 199 | + value = get_bits_le(gbc, width); | |
| 200 | + | |
| 201 | + CBS_TRACE_READ_END(); | |
| 202 | + | |
| 203 | + *write_to = value; | |
| 204 | + return 0; | |
| 205 | +} | |
| 206 | + | |
| 207 | +#define HEADER(name) \ | |
| 208 | + do { \ | |
| 209 | + ff_cbs_trace_header(ctx, name); \ | |
| 210 | + } while (0) | |
| 211 | + | |
| 212 | +#define CHECK(call) \ | |
| 213 | + do { \ | |
| 214 | + int err = (call); \ | |
| 215 | + if (err < 0) \ | |
| 216 | + return err; \ | |
| 217 | + } while (0) | |
| 218 | + | |
| 219 | +#define FUNC_NAME(rw, codec, name) cbs_##codec##_##rw##_##name | |
| 220 | +#define FUNC_VP8(rw, name) FUNC_NAME(rw, vp8, name) | |
| 221 | +#define FUNC(name) FUNC_VP8(READWRITE, name) | |
| 222 | + | |
| 223 | +#define SUBSCRIPTS(subs, ...) \ | |
| 224 | + (subs > 0 ? ((int[subs + 1]){subs, __VA_ARGS__}) : NULL) | |
| 225 | + | |
| 226 | +#define f(width, name) xf(width, name, 0) | |
| 227 | + | |
| 228 | +// bool [de|en]coder methods. | |
| 229 | +#define bc_f(width, name) bc_unsigned_subs(width, DEFAULT_PROB, true, name, 0) | |
| 230 | +#define bc_s(width, name) bc_signed_subs(width, DEFAULT_PROB, name, 0) | |
| 231 | +#define bc_fs(width, name, subs, ...) \ | |
| 232 | + bc_unsigned_subs(width, DEFAULT_PROB, true, name, subs, __VA_ARGS__) | |
| 233 | +#define bc_ss(width, name, subs, ...) \ | |
| 234 | + bc_signed_subs(width, DEFAULT_PROB, name, subs, __VA_ARGS__) | |
| 235 | + | |
| 236 | +// bool [de|en]coder methods for boolean value and disable tracing. | |
| 237 | +#define bc_b(name) bc_unsigned_subs(1, DEFAULT_PROB, false, name, 0) | |
| 238 | +#define bc_b_prob(prob, name) bc_unsigned_subs(1, prob, false, name, 0) | |
| 239 | + | |
| 240 | +#define READ | |
| 241 | +#define READWRITE read | |
| 242 | +#define RWContext GetBitContext | |
| 243 | +#define CBSVP8BoolCodingRW CBSVP8BoolDecoder | |
| 244 | + | |
| 245 | +#define xf(width, name, subs, ...) \ | |
| 246 | + do { \ | |
| 247 | + uint32_t value; \ | |
| 248 | + CHECK(cbs_vp8_read_unsigned_le(ctx, rw, width, #name, \ | |
| 249 | + SUBSCRIPTS(subs, __VA_ARGS__), &value)); \ | |
| 250 | + current->name = value; \ | |
| 251 | + } while (0) | |
| 252 | + | |
| 253 | +#define fixed(width, name, value) \ | |
| 254 | + do { \ | |
| 255 | + uint32_t fixed_value; \ | |
| 256 | + CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, 0, &fixed_value, \ | |
| 257 | + value, value)); \ | |
| 258 | + } while (0) | |
| 259 | + | |
| 260 | +#define bc_unsigned_subs(width, prob, enable_trace, name, subs, ...) \ | |
| 261 | + do { \ | |
| 262 | + uint32_t value; \ | |
| 263 | + CHECK(cbs_vp8_bool_decoder_read_unsigned( \ | |
| 264 | + ctx, bool_coding_rw, width, prob, #name, \ | |
| 265 | + SUBSCRIPTS(subs, __VA_ARGS__), &value, enable_trace)); \ | |
| 266 | + current->name = value; \ | |
| 267 | + } while (0) | |
| 268 | + | |
| 269 | +#define bc_signed_subs(width, prob, name, subs, ...) \ | |
| 270 | + do { \ | |
| 271 | + int32_t value; \ | |
| 272 | + CHECK(cbs_vp8_bool_decoder_read_signed( \ | |
| 273 | + ctx, bool_coding_rw, width, prob, #name, \ | |
| 274 | + SUBSCRIPTS(subs, __VA_ARGS__), &value)); \ | |
| 275 | + current->name = value; \ | |
| 276 | + } while (0) | |
| 277 | + | |
| 278 | +#include "cbs_vp8_syntax_template.c" | |
| 279 | + | |
| 280 | +static int cbs_vp8_split_fragment(CodedBitstreamContext *ctx, | |
| 281 | + CodedBitstreamFragment *frag, int header) | |
| 282 | +{ | |
| 283 | + int err; | |
| 284 | + | |
| 285 | + if (frag->data_size == 0) | |
| 286 | + return AVERROR_INVALIDDATA; | |
| 287 | + | |
| 288 | + err = ff_cbs_append_unit_data(frag, 0, frag->data, frag->data_size, | |
| 289 | + frag->data_ref); | |
| 290 | + if (err < 0) | |
| 291 | + return err; | |
| 292 | + | |
| 293 | + return 0; | |
| 294 | +} | |
| 295 | + | |
| 296 | +static int cbs_vp8_read_unit(CodedBitstreamContext *ctx, | |
| 297 | + CodedBitstreamUnit *unit) | |
| 298 | +{ | |
| 299 | + VP8RawFrame *frame; | |
| 300 | + GetBitContext gbc; | |
| 301 | + CBSVP8BoolDecoder bool_decoder; | |
| 302 | + int err, pos; | |
| 303 | + | |
| 304 | + err = ff_cbs_alloc_unit_content(ctx, unit); | |
| 305 | + if (err < 0) | |
| 306 | + return err; | |
| 307 | + frame = unit->content; | |
| 308 | + | |
| 309 | + // Create GetBitContext for uncompressed header. | |
| 310 | + err = init_get_bits8_le(&gbc, unit->data, 8 * unit->data_size); | |
| 311 | + if (err < 0) | |
| 312 | + return err; | |
| 313 | + | |
| 314 | + err = cbs_vp8_read_uncompressed_header(ctx, &gbc, frame); | |
| 315 | + if (err < 0) | |
| 316 | + return err; | |
| 317 | + | |
| 318 | + pos = get_bits_count(&gbc); | |
| 319 | + av_assert0(pos % 8 == 0); | |
| 320 | + | |
| 321 | + // Create boolean decoder for compressed header. | |
| 322 | + err = cbs_vp8_bool_decoder_init(&bool_decoder, &gbc); | |
| 323 | + if (err < 0) | |
| 324 | + return err; | |
| 325 | + | |
| 326 | + err = cbs_vp8_read_compressed_header(ctx, &bool_decoder, frame); | |
| 327 | + if (err < 0) | |
| 328 | + return err; | |
| 329 | + | |
| 330 | + pos = get_bits_count(&gbc); | |
| 331 | + pos /= 8; | |
| 332 | + av_assert0(pos <= unit->data_size); | |
| 333 | + | |
| 334 | + frame->data_ref = av_buffer_ref(unit->data_ref); | |
| 335 | + if (!frame->data_ref) | |
| 336 | + return AVERROR(ENOMEM); | |
| 337 | + | |
| 338 | + frame->data = unit->data + pos; | |
| 339 | + frame->data_size = unit->data_size - pos; | |
| 340 | + | |
| 341 | + return 0; | |
| 342 | +} | |
| 343 | + | |
| 344 | +static int cbs_vp8_write_unit(CodedBitstreamContext *ctx, | |
| 345 | + CodedBitstreamUnit *unit, PutBitContext *pbc) | |
| 346 | +{ | |
| 347 | + return AVERROR_PATCHWELCOME; | |
| 348 | +} | |
| 349 | + | |
| 350 | +static int cbs_vp8_assemble_fragment(CodedBitstreamContext *ctx, | |
| 351 | + CodedBitstreamFragment *frag) | |
| 352 | +{ | |
| 353 | + return AVERROR_PATCHWELCOME; | |
| 354 | +} | |
| 355 | + | |
| 356 | +static void cbs_vp8_flush(CodedBitstreamContext *ctx) | |
| 357 | +{ | |
| 358 | + // Do nothing. | |
| 359 | +} | |
| 360 | + | |
| 361 | +static const CodedBitstreamUnitTypeDescriptor cbs_vp8_unit_types[] = { | |
| 362 | + CBS_UNIT_TYPE_INTERNAL_REF(0, VP8RawFrame, data), | |
| 363 | + CBS_UNIT_TYPE_END_OF_LIST, | |
| 364 | +}; | |
| 365 | + | |
| 366 | +const CodedBitstreamType ff_cbs_type_vp8 = { | |
| 367 | + .codec_id = AV_CODEC_ID_VP8, | |
| 368 | + | |
| 369 | + .priv_data_size = 0, | |
| 370 | + | |
| 371 | + .unit_types = cbs_vp8_unit_types, | |
| 372 | + | |
| 373 | + .split_fragment = &cbs_vp8_split_fragment, | |
| 374 | + .read_unit = &cbs_vp8_read_unit, | |
| 375 | + .write_unit = &cbs_vp8_write_unit, | |
| 376 | + | |
| 377 | + .flush = &cbs_vp8_flush, | |
| 378 | + | |
| 379 | + .assemble_fragment = &cbs_vp8_assemble_fragment, | |
| 380 | +}; | |
| @@ -0,0 +1,133 @@ | ||
| 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 | +#ifndef AVCODEC_CBS_VP8_H | |
| 20 | +#define AVCODEC_CBS_VP8_H | |
| 21 | + | |
| 22 | +#include <stddef.h> | |
| 23 | +#include <stdint.h> | |
| 24 | + | |
| 25 | +#include "cbs.h" | |
| 26 | + | |
| 27 | +enum { | |
| 28 | + VP8_START_CODE_0 = 0x9D, | |
| 29 | + VP8_START_CODE_1 = 0x01, | |
| 30 | + VP8_START_CODE_2 = 0x2A, | |
| 31 | +}; | |
| 32 | + | |
| 33 | +enum { | |
| 34 | + VP8_KEY_FRAME = 0, | |
| 35 | + VP8_NON_KEY_FRAME = 1, | |
| 36 | +}; | |
| 37 | + | |
| 38 | +typedef struct VP8RawFrameHeader { | |
| 39 | + // frame tag | |
| 40 | + uint8_t frame_type; | |
| 41 | + uint8_t profile; | |
| 42 | + uint8_t show_frame; | |
| 43 | + uint32_t first_partition_length_in_bytes; | |
| 44 | + | |
| 45 | + uint16_t width; | |
| 46 | + uint8_t horizontal_scale; | |
| 47 | + uint16_t height; | |
| 48 | + uint8_t vertical_scale; | |
| 49 | + | |
| 50 | + // frame header | |
| 51 | + uint8_t color_space; | |
| 52 | + uint8_t clamping_type; | |
| 53 | + | |
| 54 | + // segmentation | |
| 55 | + uint8_t segmentation_enable; | |
| 56 | + uint8_t update_segment_map; | |
| 57 | + uint8_t update_segment_feature_data; | |
| 58 | + uint8_t segment_feature_mode; | |
| 59 | + uint8_t segment_qp_update[4]; | |
| 60 | + int8_t segment_qp[4]; | |
| 61 | + uint8_t segment_loop_filter_level_update[4]; | |
| 62 | + int8_t segment_loop_filter_level[4]; | |
| 63 | + uint8_t segment_probs_update[3]; | |
| 64 | + uint8_t segment_probs[3]; | |
| 65 | + | |
| 66 | + // loop filter | |
| 67 | + uint8_t loop_filter_type; | |
| 68 | + uint8_t loop_filter_level; | |
| 69 | + uint8_t loop_filter_sharpness; | |
| 70 | + uint8_t mode_ref_lf_delta_enable; | |
| 71 | + uint8_t mode_ref_lf_delta_update; | |
| 72 | + uint8_t ref_lf_deltas_update[4]; | |
| 73 | + int8_t ref_lf_deltas[4]; | |
| 74 | + uint8_t mode_lf_deltas_update[4]; | |
| 75 | + int8_t mode_lf_deltas[4]; | |
| 76 | + | |
| 77 | + uint8_t log2_token_partitions; | |
| 78 | + | |
| 79 | + // qp | |
| 80 | + uint8_t base_qindex; | |
| 81 | + uint8_t y1dc_delta_q_present; | |
| 82 | + int8_t y1dc_delta_q; | |
| 83 | + uint8_t y2dc_delta_q_present; | |
| 84 | + int8_t y2dc_delta_q; | |
| 85 | + uint8_t y2ac_delta_q_present; | |
| 86 | + int8_t y2ac_delta_q; | |
| 87 | + uint8_t uvdc_delta_q_present; | |
| 88 | + int8_t uvdc_delta_q; | |
| 89 | + uint8_t uvac_delta_q_present; | |
| 90 | + int8_t uvac_delta_q; | |
| 91 | + | |
| 92 | + // ref | |
| 93 | + uint8_t refresh_golden_frame; | |
| 94 | + uint8_t refresh_alternate_frame; | |
| 95 | + uint8_t copy_buffer_to_golden; | |
| 96 | + uint8_t copy_buffer_to_alternate; | |
| 97 | + uint8_t ref_frame_sign_bias_golden; | |
| 98 | + uint8_t ref_frame_sign_bias_alternate; | |
| 99 | + uint8_t refresh_last_frame; | |
| 100 | + | |
| 101 | + uint8_t refresh_entropy_probs; | |
| 102 | + | |
| 103 | + // token probs | |
| 104 | + uint8_t coeff_prob_update[4][8][3][11]; | |
| 105 | + uint8_t coeff_prob[4][8][3][11]; | |
| 106 | + | |
| 107 | + uint8_t mb_no_skip_coeff; | |
| 108 | + uint8_t prob_skip_false; | |
| 109 | + | |
| 110 | + uint8_t prob_intra; | |
| 111 | + uint8_t prob_last; | |
| 112 | + uint8_t prob_golden; | |
| 113 | + | |
| 114 | + uint8_t intra_16x16_prob_update; | |
| 115 | + uint8_t intra_16x16_prob[4]; | |
| 116 | + | |
| 117 | + uint8_t intra_chrome_prob_update; | |
| 118 | + uint8_t intra_chrome_prob[3]; | |
| 119 | + | |
| 120 | + // mv probs | |
| 121 | + uint8_t mv_prob_update[2][19]; | |
| 122 | + uint8_t mv_prob[2][19]; | |
| 123 | +} VP8RawFrameHeader; | |
| 124 | + | |
| 125 | +typedef struct VP8RawFrame { | |
| 126 | + VP8RawFrameHeader header; | |
| 127 | + | |
| 128 | + uint8_t *data; | |
| 129 | + AVBufferRef *data_ref; | |
| 130 | + size_t data_size; | |
| 131 | +} VP8RawFrame; | |
| 132 | + | |
| 133 | +#endif /* AVCODEC_CBS_VP8_H */ | |
| @@ -0,0 +1,248 @@ | ||
| 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, ¤t->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, ¤t->header)); | |
| 246 | + | |
| 247 | + return 0; | |
| 248 | +} | |