From 39ecf0588fb2ea4ff9b22c89e836b07f9fe2d24f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandra=20H=C3=A1jkov=C3=A1?= Date: Wed, 6 Apr 2016 20:26:48 +0200 Subject: [PATCH] webp: Convert to the new bitstream reader --- libavcodec/webp.c | 106 ++++++++++++++++++++++------------------------ 1 file changed, 50 insertions(+), 56 deletions(-) diff --git a/libavcodec/webp.c b/libavcodec/webp.c index b26399c504..a6ab52bf83 100644 --- a/libavcodec/webp.c +++ b/libavcodec/webp.c @@ -41,8 +41,8 @@ #define BITSTREAM_READER_LE #include "avcodec.h" +#include "bitstream.h" #include "bytestream.h" -#include "get_bits.h" #include "internal.h" #include "thread.h" #include "vp8.h" @@ -183,7 +183,7 @@ typedef struct ImageContext { typedef struct WebPContext { VP8Context v; /* VP8 Context used for lossy decoding */ - GetBitContext gb; /* bitstream reader for main image chunk */ + BitstreamContext bc; /* bitstream reader for main image chunk */ AVFrame *alpha_frame; /* AVFrame for alpha data decompressed from VP8L */ AVCodecContext *avctx; /* parent AVCodecContext */ int initialized; /* set once the VP8 context is initialized */ @@ -232,47 +232,41 @@ static void image_ctx_free(ImageContext *img) * - assumes 8-bit table to make reversal simpler * - assumes max depth of 2 since the max code length for WebP is 15 */ -static av_always_inline int webp_get_vlc(GetBitContext *gb, VLC_TYPE (*table)[2]) +static av_always_inline int webp_get_vlc(BitstreamContext *bc, VLC_TYPE (*table)[2]) { int n, nb_bits; unsigned int index; int code; - OPEN_READER(re, gb); - UPDATE_CACHE(re, gb); - - index = SHOW_UBITS(re, gb, 8); + index = bitstream_peek(bc, 8); index = ff_reverse[index]; code = table[index][0]; n = table[index][1]; if (n < 0) { - LAST_SKIP_BITS(re, gb, 8); - UPDATE_CACHE(re, gb); + bitstream_skip(bc, 8); nb_bits = -n; - index = SHOW_UBITS(re, gb, nb_bits); + index = bitstream_peek(bc, nb_bits); index = (ff_reverse[index] >> (8 - nb_bits)) + code; code = table[index][0]; n = table[index][1]; } - SKIP_BITS(re, gb, n); - - CLOSE_READER(re, gb); + bitstream_skip(bc, n); return code; } -static int huff_reader_get_symbol(HuffReader *r, GetBitContext *gb) +static int huff_reader_get_symbol(HuffReader *r, BitstreamContext *bc) { if (r->simple) { if (r->nb_symbols == 1) return r->simple_symbols[0]; else - return r->simple_symbols[get_bits1(gb)]; + return r->simple_symbols[bitstream_read_bit(bc)]; } else - return webp_get_vlc(gb, r->vlc.table); + return webp_get_vlc(bc, r->vlc.table); } static int huff_reader_build_canonical(HuffReader *r, int *code_lengths, @@ -339,15 +333,15 @@ static int huff_reader_build_canonical(HuffReader *r, int *code_lengths, static void read_huffman_code_simple(WebPContext *s, HuffReader *hc) { - hc->nb_symbols = get_bits1(&s->gb) + 1; + hc->nb_symbols = bitstream_read_bit(&s->bc) + 1; - if (get_bits1(&s->gb)) - hc->simple_symbols[0] = get_bits(&s->gb, 8); + if (bitstream_read_bit(&s->bc)) + hc->simple_symbols[0] = bitstream_read(&s->bc, 8); else - hc->simple_symbols[0] = get_bits1(&s->gb); + hc->simple_symbols[0] = bitstream_read_bit(&s->bc); if (hc->nb_symbols == 2) - hc->simple_symbols[1] = get_bits(&s->gb, 8); + hc->simple_symbols[1] = bitstream_read(&s->bc, 8); hc->simple = 1; } @@ -359,13 +353,13 @@ static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, int *code_lengths = NULL; int code_length_code_lengths[NUM_CODE_LENGTH_CODES] = { 0 }; int i, symbol, max_symbol, prev_code_len, ret; - int num_codes = 4 + get_bits(&s->gb, 4); + int num_codes = 4 + bitstream_read(&s->bc, 4); if (num_codes > NUM_CODE_LENGTH_CODES) return AVERROR_INVALIDDATA; for (i = 0; i < num_codes; i++) - code_length_code_lengths[code_length_code_order[i]] = get_bits(&s->gb, 3); + code_length_code_lengths[code_length_code_order[i]] = bitstream_read(&s->bc, 3); ret = huff_reader_build_canonical(&code_len_hc, code_length_code_lengths, NUM_CODE_LENGTH_CODES); @@ -378,9 +372,9 @@ static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, goto finish; } - if (get_bits1(&s->gb)) { - int bits = 2 + 2 * get_bits(&s->gb, 3); - max_symbol = 2 + get_bits(&s->gb, bits); + if (bitstream_read_bit(&s->bc)) { + int bits = 2 + 2 * bitstream_read(&s->bc, 3); + max_symbol = 2 + bitstream_read(&s->bc, bits); if (max_symbol > alphabet_size) { av_log(s->avctx, AV_LOG_ERROR, "max symbol %d > alphabet size %d\n", max_symbol, alphabet_size); @@ -398,7 +392,7 @@ static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, if (!max_symbol--) break; - code_len = huff_reader_get_symbol(&code_len_hc, &s->gb); + code_len = huff_reader_get_symbol(&code_len_hc, &s->bc); if (code_len < 16) { /* Code length code [0..15] indicates literal code lengths. */ code_lengths[symbol++] = code_len; @@ -411,18 +405,18 @@ static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, /* Code 16 repeats the previous non-zero value [3..6] times, * i.e., 3 + ReadBits(2) times. If code 16 is used before a * non-zero value has been emitted, a value of 8 is repeated. */ - repeat = 3 + get_bits(&s->gb, 2); + repeat = 3 + bitstream_read(&s->bc, 2); length = prev_code_len; break; case 17: /* Code 17 emits a streak of zeros [3..10], i.e., * 3 + ReadBits(3) times. */ - repeat = 3 + get_bits(&s->gb, 3); + repeat = 3 + bitstream_read(&s->bc, 3); break; case 18: /* Code 18 emits a streak of zeros of length [11..138], i.e., * 11 + ReadBits(7) times. */ - repeat = 11 + get_bits(&s->gb, 7); + repeat = 11 + bitstream_read(&s->bc, 7); break; } if (symbol + repeat > alphabet_size) { @@ -449,7 +443,7 @@ static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, int w, int h); #define PARSE_BLOCK_SIZE(w, h) do { \ - block_bits = get_bits(&s->gb, 3) + 2; \ + block_bits = bitstream_read(&s->bc, 3) + 2; \ blocks_w = FFALIGN((w), 1 << block_bits) >> block_bits; \ blocks_h = FFALIGN((h), 1 << block_bits) >> block_bits; \ } while (0) @@ -526,7 +520,7 @@ static int parse_transform_color_indexing(WebPContext *s) int width_bits, index_size, ret, x; uint8_t *ct; - index_size = get_bits(&s->gb, 8) + 1; + index_size = bitstream_read(&s->bc, 8) + 1; if (index_size <= 2) width_bits = 3; @@ -606,8 +600,8 @@ static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, if (ret < 0) return ret; - if (get_bits1(&s->gb)) { - img->color_cache_bits = get_bits(&s->gb, 4); + if (bitstream_read_bit(&s->bc)) { + img->color_cache_bits = bitstream_read(&s->bc, 4); if (img->color_cache_bits < 1 || img->color_cache_bits > 11) { av_log(s->avctx, AV_LOG_ERROR, "invalid color cache bits: %d\n", img->color_cache_bits); @@ -622,7 +616,7 @@ static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, } img->nb_huffman_groups = 1; - if (role == IMAGE_ROLE_ARGB && get_bits1(&s->gb)) { + if (role == IMAGE_ROLE_ARGB && bitstream_read_bit(&s->bc)) { ret = decode_entropy_image(s); if (ret < 0) return ret; @@ -641,7 +635,7 @@ static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, if (!j && img->color_cache_bits > 0) alphabet_size += 1 << img->color_cache_bits; - if (get_bits1(&s->gb)) { + if (bitstream_read_bit(&s->bc)) { read_huffman_code_simple(s, &hg[j]); } else { ret = read_huffman_code_normal(s, &hg[j], alphabet_size); @@ -660,14 +654,14 @@ static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, int v; hg = get_huffman_group(s, img, x, y); - v = huff_reader_get_symbol(&hg[HUFF_IDX_GREEN], &s->gb); + v = huff_reader_get_symbol(&hg[HUFF_IDX_GREEN], &s->bc); if (v < NUM_LITERAL_CODES) { /* literal pixel values */ uint8_t *p = GET_PIXEL(img->frame, x, y); p[2] = v; - p[1] = huff_reader_get_symbol(&hg[HUFF_IDX_RED], &s->gb); - p[3] = huff_reader_get_symbol(&hg[HUFF_IDX_BLUE], &s->gb); - p[0] = huff_reader_get_symbol(&hg[HUFF_IDX_ALPHA], &s->gb); + p[1] = huff_reader_get_symbol(&hg[HUFF_IDX_RED], &s->bc); + p[3] = huff_reader_get_symbol(&hg[HUFF_IDX_BLUE], &s->bc); + p[0] = huff_reader_get_symbol(&hg[HUFF_IDX_ALPHA], &s->bc); if (img->color_cache_bits) color_cache_put(img, AV_RB32(p)); x++; @@ -686,9 +680,9 @@ static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, } else { int extra_bits = (prefix_code - 2) >> 1; int offset = 2 + (prefix_code & 1) << extra_bits; - length = offset + get_bits(&s->gb, extra_bits) + 1; + length = offset + bitstream_read(&s->bc, extra_bits) + 1; } - prefix_code = huff_reader_get_symbol(&hg[HUFF_IDX_DIST], &s->gb); + prefix_code = huff_reader_get_symbol(&hg[HUFF_IDX_DIST], &s->bc); if (prefix_code > 39) { av_log(s->avctx, AV_LOG_ERROR, "distance prefix code too large: %d\n", prefix_code); @@ -699,7 +693,7 @@ static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, } else { int extra_bits = prefix_code - 2 >> 1; int offset = 2 + (prefix_code & 1) << extra_bits; - distance = offset + get_bits(&s->gb, extra_bits) + 1; + distance = offset + bitstream_read(&s->bc, extra_bits) + 1; } /* find reference location */ @@ -1034,7 +1028,7 @@ static int apply_color_indexing_transform(WebPContext *s) pal = &s->image[IMAGE_ROLE_COLOR_INDEXING]; if (pal->size_reduction > 0) { - GetBitContext gb_g; + BitstreamContext bc_g; uint8_t *line; int pixel_bits = 8 >> pal->size_reduction; @@ -1045,15 +1039,15 @@ static int apply_color_indexing_transform(WebPContext *s) for (y = 0; y < img->frame->height; y++) { p = GET_PIXEL(img->frame, 0, y); memcpy(line, p, img->frame->linesize[0]); - init_get_bits(&gb_g, line, img->frame->linesize[0] * 8); - skip_bits(&gb_g, 16); + bitstream_init(&bc_g, line, img->frame->linesize[0] * 8); + bitstream_skip(&bc_g, 16); i = 0; for (x = 0; x < img->frame->width; x++) { p = GET_PIXEL(img->frame, x, y); - p[2] = get_bits(&gb_g, pixel_bits); + p[2] = bitstream_read(&bc_g, pixel_bits); i++; if (i == 1 << pal->size_reduction) { - skip_bits(&gb_g, 24); + bitstream_skip(&bc_g, 24); i = 0; } } @@ -1089,18 +1083,18 @@ static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p, avctx->pix_fmt = AV_PIX_FMT_ARGB; } - ret = init_get_bits(&s->gb, data_start, data_size * 8); + ret = bitstream_init(&s->bc, data_start, data_size * 8); if (ret < 0) return ret; if (!is_alpha_chunk) { - if (get_bits(&s->gb, 8) != 0x2F) { + if (bitstream_read(&s->bc, 8) != 0x2F) { av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless signature\n"); return AVERROR_INVALIDDATA; } - w = get_bits(&s->gb, 14) + 1; - h = get_bits(&s->gb, 14) + 1; + w = bitstream_read(&s->bc, 14) + 1; + h = bitstream_read(&s->bc, 14) + 1; if (s->width && s->width != w) { av_log(avctx, AV_LOG_WARNING, "Width mismatch. %d != %d\n", s->width, w); @@ -1116,9 +1110,9 @@ static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p, if (ret < 0) return ret; - s->has_alpha = get_bits1(&s->gb); + s->has_alpha = bitstream_read_bit(&s->bc); - if (get_bits(&s->gb, 3) != 0x0) { + if (bitstream_read(&s->bc, 3) != 0x0) { av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless version\n"); return AVERROR_INVALIDDATA; } @@ -1133,8 +1127,8 @@ static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p, s->nb_transforms = 0; s->reduced_width = 0; used = 0; - while (get_bits1(&s->gb)) { - enum TransformType transform = get_bits(&s->gb, 2); + while (bitstream_read_bit(&s->bc)) { + enum TransformType transform = bitstream_read(&s->bc, 2); s->transforms[s->nb_transforms++] = transform; if (used & (1 << transform)) { av_log(avctx, AV_LOG_ERROR, "Transform %d used more than once\n",