X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fescape124.c;h=86a63a434e39b3cee63861ff343704c8f0c0da87;hb=752ddb45569ffe278393cd853b70f18ae017219e;hp=af14e0d7e5ba1fc18aa6d8a78d886a02f9d40a2f;hpb=bd7d08e27e54031a2614b800924fa4bee7ef858b;p=ffmpeg diff --git a/libavcodec/escape124.c b/libavcodec/escape124.c index af14e0d7e5b..86a63a434e3 100644 --- a/libavcodec/escape124.c +++ b/libavcodec/escape124.c @@ -2,27 +2,27 @@ * Escape 124 Video Decoder * Copyright (C) 2008 Eli Friedman (eli.friedman@gmail.com) * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * Libav 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. * - * FFmpeg is distributed in the hope that it will be useful, + * Libav 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 FFmpeg; if not, write to the Free Software + * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#define BITSTREAM_READER_LE #include "avcodec.h" - -#define ALT_BITSTREAM_READER_LE -#include "get_bits.h" +#include "bitstream.h" +#include "internal.h" typedef union MacroBlock { uint16_t pixels[4]; @@ -41,15 +41,16 @@ typedef struct CodeBook { } CodeBook; typedef struct Escape124Context { - AVFrame frame; + AVFrame *frame; unsigned num_superblocks; CodeBook codebooks[3]; } Escape124Context; -static int can_safely_read(GetBitContext* gb, int bits) { - return get_bits_count(gb) + bits <= gb->size_in_bits; +static int can_safely_read(BitstreamContext *bc, int bits) +{ + return bitstream_bits_left(bc) >= bits; } /** @@ -61,11 +62,15 @@ static av_cold int escape124_decode_init(AVCodecContext *avctx) { Escape124Context *s = avctx->priv_data; - avctx->pix_fmt = PIX_FMT_RGB555; + avctx->pix_fmt = AV_PIX_FMT_RGB555; s->num_superblocks = ((unsigned)avctx->width / 8) * ((unsigned)avctx->height / 8); + s->frame = av_frame_alloc(); + if (!s->frame) + return AVERROR(ENOMEM); + return 0; } @@ -77,19 +82,18 @@ static av_cold int escape124_decode_close(AVCodecContext *avctx) for (i = 0; i < 3; i++) av_free(s->codebooks[i].blocks); - if (s->frame.data[0]) - avctx->release_buffer(avctx, &s->frame); + av_frame_free(&s->frame); return 0; } -static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth, +static CodeBook unpack_codebook(BitstreamContext *bc, unsigned depth, unsigned size) { unsigned i, j; CodeBook cb = { 0 }; - if (!can_safely_read(gb, size * 34)) + if (!can_safely_read(bc, size * 34)) return cb; if (size >= INT_MAX / sizeof(MacroBlock)) @@ -101,9 +105,9 @@ static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth, cb.depth = depth; cb.size = size; for (i = 0; i < size; i++) { - unsigned mask_bits = get_bits(gb, 4); - unsigned color0 = get_bits(gb, 15); - unsigned color1 = get_bits(gb, 15); + unsigned mask_bits = bitstream_read(bc, 4); + unsigned color0 = bitstream_read(bc, 15); + unsigned color1 = bitstream_read(bc, 15); for (j = 0; j < 4; j++) { if (mask_bits & (1 << j)) @@ -115,46 +119,43 @@ static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth, return cb; } -static unsigned decode_skip_count(GetBitContext* gb) +static unsigned decode_skip_count(BitstreamContext *bc) { unsigned value; // This function reads a maximum of 23 bits, // which is within the padding space - if (!can_safely_read(gb, 1)) + if (!can_safely_read(bc, 1)) return -1; - value = get_bits1(gb); + value = bitstream_read_bit(bc); if (!value) return value; - value += get_bits(gb, 3); + value += bitstream_read(bc, 3); if (value != (1 + ((1 << 3) - 1))) return value; - value += get_bits(gb, 7); + value += bitstream_read(bc, 7); if (value != (1 + ((1 << 3) - 1)) + ((1 << 7) - 1)) return value; - return value + get_bits(gb, 12); + return value + bitstream_read(bc, 12); } -static MacroBlock decode_macroblock(Escape124Context* s, GetBitContext* gb, - int* codebook_index, int superblock_index) +static MacroBlock decode_macroblock(Escape124Context *s, BitstreamContext *bc, + int *codebook_index, int superblock_index) { // This function reads a maximum of 22 bits; the callers // guard this function appropriately unsigned block_index, depth; - - if (get_bits1(gb)) { + int value = bitstream_read_bit(bc); + if (value) { static const char transitions[3][2] = { {2, 1}, {0, 2}, {1, 0} }; - *codebook_index = transitions[*codebook_index][get_bits1(gb)]; + value = bitstream_read_bit(bc); + *codebook_index = transitions[*codebook_index][value]; } depth = s->codebooks[*codebook_index].depth; - - // depth = 0 means that this shouldn't read any bits; - // in theory, this is the same as get_bits(gb, 0), but - // that doesn't actually work. - block_index = depth ? get_bits(gb, depth) : 0; + block_index = bitstream_read(bc, depth); if (*codebook_index == 1) { block_index += superblock_index << s->codebooks[1].depth; @@ -196,14 +197,15 @@ static const uint16_t mask_matrix[] = {0x1, 0x2, 0x10, 0x20, 0x400, 0x800, 0x4000, 0x8000}; static int escape124_decode_frame(AVCodecContext *avctx, - void *data, int *data_size, + void *data, int *got_frame, AVPacket *avpkt) { const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; Escape124Context *s = avctx->priv_data; + AVFrame *frame = data; - GetBitContext gb; + BitstreamContext bc; unsigned frame_flags, frame_size; unsigned i; @@ -213,26 +215,29 @@ static int escape124_decode_frame(AVCodecContext *avctx, uint16_t* old_frame_data, *new_frame_data; unsigned old_stride, new_stride; + int ret; - AVFrame new_frame = { { 0 } }; - - init_get_bits(&gb, buf, buf_size * 8); + bitstream_init8(&bc, buf, buf_size); // This call also guards the potential depth reads for the // codebook unpacking. - if (!can_safely_read(&gb, 64)) + if (!can_safely_read(&bc, 64)) return -1; - frame_flags = get_bits_long(&gb, 32); - frame_size = get_bits_long(&gb, 32); + frame_flags = bitstream_read(&bc, 32); + frame_size = bitstream_read(&bc, 32); // Leave last frame unchanged // FIXME: Is this necessary? I haven't seen it in any real samples if (!(frame_flags & 0x114) || !(frame_flags & 0x7800000)) { + if (!s->frame->data[0]) + return AVERROR_INVALIDDATA; + av_log(NULL, AV_LOG_DEBUG, "Skipping frame\n"); - *data_size = sizeof(AVFrame); - *(AVFrame*)data = s->frame; + *got_frame = 1; + if ((ret = av_frame_ref(frame, s->frame)) < 0) + return ret; return frame_size; } @@ -243,10 +248,10 @@ static int escape124_decode_frame(AVCodecContext *avctx, if (i == 2) { // This codebook can be cut off at places other than // powers of 2, leaving some of the entries undefined. - cb_size = get_bits_long(&gb, 20); + cb_size = bitstream_read(&bc, 20); cb_depth = av_log2(cb_size - 1) + 1; } else { - cb_depth = get_bits(&gb, 4); + cb_depth = bitstream_read(&bc, 4); if (i == 0) { // This is the most basic codebook: pow(2,depth) entries // for a depth-length key @@ -259,22 +264,21 @@ static int escape124_decode_frame(AVCodecContext *avctx, } } av_free(s->codebooks[i].blocks); - s->codebooks[i] = unpack_codebook(&gb, cb_depth, cb_size); + s->codebooks[i] = unpack_codebook(&bc, cb_depth, cb_size); if (!s->codebooks[i].blocks) return -1; } } - new_frame.reference = 3; - if (avctx->get_buffer(avctx, &new_frame)) { + if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0) { av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); - return -1; + return ret; } - new_frame_data = (uint16_t*)new_frame.data[0]; - new_stride = new_frame.linesize[0] / 2; - old_frame_data = (uint16_t*)s->frame.data[0]; - old_stride = s->frame.linesize[0] / 2; + new_frame_data = (uint16_t*)frame->data[0]; + new_stride = frame->linesize[0] / 2; + old_frame_data = (uint16_t*)s->frame->data[0]; + old_stride = s->frame->linesize[0] / 2; for (superblock_index = 0; superblock_index < s->num_superblocks; superblock_index++) { @@ -285,7 +289,7 @@ static int escape124_decode_frame(AVCodecContext *avctx, if (skip == -1) { // Note that this call will make us skip the rest of the blocks // if the frame prematurely ends - skip = decode_skip_count(&gb); + skip = decode_skip_count(&bc); } if (skip) { @@ -295,10 +299,10 @@ static int escape124_decode_frame(AVCodecContext *avctx, copy_superblock(sb.pixels, 8, old_frame_data, old_stride); - while (can_safely_read(&gb, 1) && !get_bits1(&gb)) { + while (can_safely_read(&bc, 1) && !bitstream_read_bit(&bc)) { unsigned mask; - mb = decode_macroblock(s, &gb, &cb_index, superblock_index); - mask = get_bits(&gb, 16); + mb = decode_macroblock(s, &bc, &cb_index, superblock_index); + mask = bitstream_read(&bc, 16); multi_mask |= mask; for (i = 0; i < 16; i++) { if (mask & mask_matrix[i]) { @@ -307,29 +311,29 @@ static int escape124_decode_frame(AVCodecContext *avctx, } } - if (can_safely_read(&gb, 1) && !get_bits1(&gb)) { - unsigned inv_mask = get_bits(&gb, 4); + if (can_safely_read(&bc, 1) && !bitstream_read_bit(&bc)) { + unsigned inv_mask = bitstream_read(&bc, 4); for (i = 0; i < 4; i++) { if (inv_mask & (1 << i)) { multi_mask ^= 0xF << i*4; } else { - multi_mask ^= get_bits(&gb, 4) << i*4; + multi_mask ^= bitstream_read(&bc, 4) << i * 4; } } for (i = 0; i < 16; i++) { if (multi_mask & mask_matrix[i]) { - if (!can_safely_read(&gb, 1)) + if (!can_safely_read(&bc, 1)) break; - mb = decode_macroblock(s, &gb, &cb_index, + mb = decode_macroblock(s, &bc, &cb_index, superblock_index); insert_mb_into_sb(&sb, mb, i); } } } else if (frame_flags & (1 << 16)) { - while (can_safely_read(&gb, 1) && !get_bits1(&gb)) { - mb = decode_macroblock(s, &gb, &cb_index, superblock_index); - insert_mb_into_sb(&sb, mb, get_bits(&gb, 4)); + while (can_safely_read(&bc, 1) && !bitstream_read_bit(&bc)) { + mb = decode_macroblock(s, &bc, &cb_index, superblock_index); + insert_mb_into_sb(&sb, mb, bitstream_read(&bc, 4)); } } @@ -351,28 +355,26 @@ static int escape124_decode_frame(AVCodecContext *avctx, av_log(NULL, AV_LOG_DEBUG, "Escape sizes: %i, %i, %i\n", - frame_size, buf_size, get_bits_count(&gb) / 8); + frame_size, buf_size, bitstream_tell(&bc) / 8); - if (s->frame.data[0]) - avctx->release_buffer(avctx, &s->frame); + av_frame_unref(s->frame); + if ((ret = av_frame_ref(s->frame, frame)) < 0) + return ret; - *(AVFrame*)data = s->frame = new_frame; - *data_size = sizeof(AVFrame); + *got_frame = 1; return frame_size; } -AVCodec escape124_decoder = { - "escape124", - AVMEDIA_TYPE_VIDEO, - CODEC_ID_ESCAPE124, - sizeof(Escape124Context), - escape124_decode_init, - NULL, - escape124_decode_close, - escape124_decode_frame, - CODEC_CAP_DR1, - .long_name = NULL_IF_CONFIG_SMALL("Escape 124"), +AVCodec ff_escape124_decoder = { + .name = "escape124", + .long_name = NULL_IF_CONFIG_SMALL("Escape 124"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_ESCAPE124, + .priv_data_size = sizeof(Escape124Context), + .init = escape124_decode_init, + .close = escape124_decode_close, + .decode = escape124_decode_frame, + .capabilities = AV_CODEC_CAP_DR1, }; -