X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fvble.c;h=57b3599ddb975688084b05c0fba331db62c7283e;hb=dd3ca3ea15392da8636c06764e2da31e6ca700f0;hp=436402ded447421017191afbc06196a1e7ed47af;hpb=c433a3f9a5ead7bd107384e20ea21de9f4c3f911;p=ffmpeg diff --git a/libavcodec/vble.c b/libavcodec/vble.c index 436402ded44..57b3599ddb9 100644 --- a/libavcodec/vble.c +++ b/libavcodec/vble.c @@ -2,20 +2,20 @@ * VBLE Decoder * Copyright (c) 2011 Derek Buitenhuis * - * This file is part of Libav. + * This file is part of FFmpeg. * - * Libav is free software; you can redistribute it and/or + * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * - * Libav is distributed in the hope that it will be useful, + * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with Libav; if not, write to the Free Software + * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ @@ -24,99 +24,88 @@ * VBLE Decoder */ -#define ALT_BITSTREAM_READER_LE +#define BITSTREAM_READER_LE #include "avcodec.h" +#include "dsputil.h" #include "get_bits.h" typedef struct { AVCodecContext *avctx; + DSPContext dsp; int size; - int flags; - uint8_t *len; - uint8_t *val; + uint8_t *val; ///< This array first holds the lengths of vlc symbols and then their value. } VBLEContext; -static uint8_t vble_read_reverse_unary(GetBitContext *gb) -{ - /* At most we need to read 9 bits total to get indices up to 8 */ - uint8_t val = show_bits(gb, 8); - - if (val) { - val = 7 - av_log2_16bit(av_reverse[val]); - skip_bits(gb, val + 1); - return val; - } else { - skip_bits(gb, 8); - if (get_bits1(gb)) - return 8; - } - - /* Return something larger than 8 on error */ - return UINT8_MAX; -} - static int vble_unpack(VBLEContext *ctx, GetBitContext *gb) { int i; + int allbits = 0; + static const uint8_t LUT[256] = { + 8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0, + 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0, + 6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0, + 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0, + 7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0, + 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0, + 6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0, + 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0, + }; /* Read all the lengths in first */ for (i = 0; i < ctx->size; i++) { - ctx->len[i] = vble_read_reverse_unary(gb); - - if (ctx->len[i] == UINT8_MAX) - return -1; - } - - /* For any values that have length 0 */ - memset(ctx->val, 0, ctx->size); - - for (i = 0; i < ctx->size; i++) { - /* Check we have enough bits left */ - if (get_bits_left(gb) < ctx->len[i]) - return -1; - - /* get_bits can't take a length of 0 */ - if (ctx->len[i]) - ctx->val[i] = (1 << ctx->len[i]) + get_bits(gb, ctx->len[i]) - 1; + /* At most we need to read 9 bits total to get indices up to 8 */ + int val = show_bits(gb, 8); + + // read reverse unary + if (val) { + val = LUT[val]; + skip_bits(gb, val + 1); + ctx->val[i] = val; + } else { + skip_bits(gb, 8); + if (!get_bits1(gb)) + return -1; + ctx->val[i] = 8; + } + allbits += ctx->val[i]; } + /* Check we have enough bits left */ + if (get_bits_left(gb) < allbits) + return -1; return 0; } -static void vble_restore_plane(VBLEContext *ctx, int plane, int offset, - int width, int height) +static void vble_restore_plane(VBLEContext *ctx, GetBitContext *gb, int plane, + int offset, int width, int height) { AVFrame *pic = ctx->avctx->coded_frame; uint8_t *dst = pic->data[plane]; uint8_t *val = ctx->val + offset; - uint8_t *len = ctx->len + offset; - uint8_t a, b, c; int stride = pic->linesize[plane]; - int i, j; + int i, j, left, left_top; for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { - dst[j] = (val[j] >> 1) ^ -(val[j] & 1); - - /* Top line and left column are not predicted */ - if (!j) - continue; - - if (!i) { - dst[j] += dst[j - 1]; - continue; + /* get_bits can't take a length of 0 */ + if (val[j]) { + int v = (1 << val[j]) + get_bits(gb, val[j]) - 1; + val[j] = (v >> 1) ^ -(v & 1); } - - a = dst[j - 1]; - b = dst[j - stride]; - c = a + b - dst[j - 1 - stride]; - dst[j] += mid_pred(a, b, c); + } + if (i) { + left = 0; + left_top = dst[-stride]; + ctx->dsp.add_hfyu_median_prediction(dst, dst-stride, val, width, &left, &left_top); + } else { + dst[0] = val[0]; + for (j = 1; j < width; j++) + dst[j] = val[j] + dst[j - 1]; } dst += stride; val += width; - len += width; } } @@ -145,7 +134,7 @@ static int vble_decode_frame(AVCodecContext *avctx, void *data, int *data_size, /* Set flags */ pic->key_frame = 1; - pic->pict_type = FF_I_TYPE; + pic->pict_type = AV_PICTURE_TYPE_I; /* Version should always be 1 */ version = AV_RL32(src); @@ -164,15 +153,15 @@ static int vble_decode_frame(AVCodecContext *avctx, void *data, int *data_size, } /* Restore planes. Should be almost identical to Huffyuv's. */ - vble_restore_plane(ctx, 0, offset, avctx->width, avctx->height); + vble_restore_plane(ctx, &gb, 0, offset, avctx->width, avctx->height); /* Chroma */ - if (!(ctx->flags & CODEC_FLAG_GRAY)) { + if (!(ctx->avctx->flags & CODEC_FLAG_GRAY)) { offset += avctx->width * avctx->height; - vble_restore_plane(ctx, 1, offset, width_uv, height_uv); + vble_restore_plane(ctx, &gb, 1, offset, width_uv, height_uv); offset += width_uv * height_uv; - vble_restore_plane(ctx, 2, offset, width_uv, height_uv); + vble_restore_plane(ctx, &gb, 2, offset, width_uv, height_uv); } *data_size = sizeof(AVFrame); @@ -190,47 +179,38 @@ static av_cold int vble_decode_close(AVCodecContext *avctx) avctx->release_buffer(avctx, pic); av_freep(&avctx->coded_frame); - av_freep(&ctx->len); av_freep(&ctx->val); return 0; } -static av_always_inline int vble_error_close(AVCodecContext *avctx, - const char *message) -{ - av_log(avctx, AV_LOG_ERROR, message); - vble_decode_close(avctx); - return AVERROR(ENOMEM); -} - static av_cold int vble_decode_init(AVCodecContext *avctx) { VBLEContext *ctx = avctx->priv_data; /* Stash for later use */ ctx->avctx = avctx; - ctx->flags = avctx->flags; + dsputil_init(&ctx->dsp, avctx); avctx->pix_fmt = PIX_FMT_YUV420P; avctx->bits_per_raw_sample = 8; avctx->coded_frame = avcodec_alloc_frame(); - if (!avctx->coded_frame) - return vble_error_close(avctx, "Could not allocate frame.\n"); + if (!avctx->coded_frame) { + av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n"); + return AVERROR(ENOMEM); + } ctx->size = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height); - ctx->len = av_malloc(ctx->size * sizeof(*ctx->len)); - - if (!ctx->len) - return vble_error_close(avctx, "Could not allocate lengths buffer.\n"); - ctx->val = av_malloc(ctx->size * sizeof(*ctx->val)); - if (!ctx->val) - return vble_error_close(avctx, "Could not allocate values buffer.\n"); + if (!ctx->val) { + av_log(avctx, AV_LOG_ERROR, "Could not allocate values buffer.\n"); + vble_decode_close(avctx); + return AVERROR(ENOMEM); + } return 0; }