From e06442afb6b154f749c4d839fd2a23e434e08dda Mon Sep 17 00:00:00 2001 From: Paul Gilbert Date: Sat, 10 Sep 2016 17:00:06 -0400 Subject: IMAGE: Cleanup of method parameters and locals in Indeo decoders --- image/codecs/indeo/indeo.cpp | 633 +++++++++++++++++++++---------------------- image/codecs/indeo/indeo.h | 156 +++++------ image/codecs/indeo4.cpp | 138 +++++----- image/codecs/indeo4.h | 14 +- image/codecs/indeo5.cpp | 173 ++++++------ image/codecs/indeo5.h | 8 +- 6 files changed, 563 insertions(+), 559 deletions(-) (limited to 'image/codecs') diff --git a/image/codecs/indeo/indeo.cpp b/image/codecs/indeo/indeo.cpp index 632e39ea7b..4f290160ed 100644 --- a/image/codecs/indeo/indeo.cpp +++ b/image/codecs/indeo/indeo.cpp @@ -81,27 +81,27 @@ static const IVIHuffDesc ivi_blk_huff_desc[8] = { /** * calculate number of _tiles in a stride */ -#define IVI_NUM_TILES(stride, tile_size) (((stride) + (tile_size) - 1) / (tile_size)) +#define IVI_NUM_TILES(stride, tileSize) (((stride) + (tileSize) - 1) / (tileSize)) /*------------------------------------------------------------------------*/ -int IVIHuffDesc::ivi_create_huff_from_desc(VLC *vlc, int flag) const { - int pos, i, j, codes_per_row, prefix, not_last_row; +int IVIHuffDesc::createHuffFromDesc(VLC *vlc, bool flag) const { + int pos, i, j, codesPerRow, prefix, notLastRow; uint16 codewords[256]; uint8 bits[256]; pos = 0; // current position = 0 for (i = 0; i < _numRows; i++) { - codes_per_row = 1 << _xBits[i]; - not_last_row = (i != _numRows - 1); - prefix = ((1 << i) - 1) << (_xBits[i] + not_last_row); + codesPerRow = 1 << _xBits[i]; + notLastRow = (i != _numRows - 1); + prefix = ((1 << i) - 1) << (_xBits[i] + notLastRow); - for (j = 0; j < codes_per_row; j++) { + for (j = 0; j < codesPerRow; j++) { if (pos >= 256) // Some Indeo5 codebooks can have more than 256 break; // elements, but only 256 codes are allowed! - bits[pos] = i + _xBits[i] + not_last_row; + bits[pos] = i + _xBits[i] + notLastRow; if (bits[pos] > IVI_VLC_BITS) return -1; // invalid descriptor @@ -120,12 +120,11 @@ int IVIHuffDesc::ivi_create_huff_from_desc(VLC *vlc, int flag) const { /*------------------------------------------------------------------------*/ -bool IVIHuffDesc::ivi_huff_desc_cmp(const IVIHuffDesc *desc2) const { - return _numRows != desc2->_numRows || - memcmp(_xBits, desc2->_xBits, _numRows); +bool IVIHuffDesc::huffDescCompare(const IVIHuffDesc *desc2) const { + return _numRows != desc2->_numRows || memcmp(_xBits, desc2->_xBits, _numRows); } -void IVIHuffDesc::ivi_huff_desc_copy(const IVIHuffDesc *src) { +void IVIHuffDesc::huffDescCopy(const IVIHuffDesc *src) { _numRows = src->_numRows; memcpy(_xBits, src->_xBits, src->_numRows); } @@ -135,13 +134,13 @@ void IVIHuffDesc::ivi_huff_desc_copy(const IVIHuffDesc *src) { IVIHuffTab::IVIHuffTab() : _tab(nullptr) { } -int IVIHuffTab::ff_ivi_dec_huff_desc(IVI45DecContext *ctx, int desc_coded, int which_tab) { +int IVIHuffTab::decodeHuffDesc(IVI45DecContext *ctx, int descCoded, int whichTab) { int i, result; - IVIHuffDesc new_huff; + IVIHuffDesc newHuff; - if (!desc_coded) { + if (!descCoded) { // select default table - _tab = (which_tab) ? &ctx->_iviBlkVlcTabs[7] + _tab = (whichTab) ? &ctx->_iviBlkVlcTabs[7] : &ctx->_iviMbVlcTabs[7]; return 0; } @@ -149,22 +148,22 @@ int IVIHuffTab::ff_ivi_dec_huff_desc(IVI45DecContext *ctx, int desc_coded, int w _tabSel = ctx->_gb->getBits(3); if (_tabSel == 7) { // custom huffman table (explicitly encoded) - new_huff._numRows = ctx->_gb->getBits(4); - if (!new_huff._numRows) { + newHuff._numRows = ctx->_gb->getBits(4); + if (!newHuff._numRows) { warning("Empty custom Huffman table!"); return -1; } - for (i = 0; i < new_huff._numRows; i++) - new_huff._xBits[i] = ctx->_gb->getBits(4); + for (i = 0; i < newHuff._numRows; i++) + newHuff._xBits[i] = ctx->_gb->getBits(4); // Have we got the same custom table? Rebuild if not. - if (new_huff.ivi_huff_desc_cmp(&_custDesc) || !_custTab._table) { - _custDesc.ivi_huff_desc_copy(&new_huff); + if (newHuff.huffDescCompare(&_custDesc) || !_custTab._table) { + _custDesc.huffDescCopy(&newHuff); if (_custTab._table) _custTab.ff_free_vlc(); - result = _custDesc.ivi_create_huff_from_desc(&_custTab, 0); + result = _custDesc.createHuffFromDesc(&_custTab, false); if (result) { // reset faulty description _custDesc._numRows = 0; @@ -175,7 +174,7 @@ int IVIHuffTab::ff_ivi_dec_huff_desc(IVI45DecContext *ctx, int desc_coded, int w _tab = &_custTab; } else { // select one of predefined tables - _tab = (which_tab) ? &ctx->_iviBlkVlcTabs[_tabSel] + _tab = (whichTab) ? &ctx->_iviBlkVlcTabs[_tabSel] : &ctx->_iviMbVlcTabs[_tabSel]; } @@ -210,17 +209,17 @@ IVIBandDesc::IVIBandDesc() : _plane(0), _bandNum(0), _width(0), _height(0), Common::fill(&_corr[0], &_corr[61 * 2], 0); } -int IVIBandDesc::ivi_init_tiles(IVITile *ref_tile, int p, int b, int t_height, int t_width) { +int IVIBandDesc::initTiles(IVITile *refTile, int p, int b, int tHeight, int tWidth) { int x, y; IVITile *tile = _tiles; - for (y = 0; y < _height; y += t_height) { - for (x = 0; x < _width; x += t_width) { + for (y = 0; y < _height; y += tHeight) { + for (x = 0; x < _width; x += tWidth) { tile->_xPos = x; tile->_yPos = y; tile->_mbSize = _mbSize; - tile->_width = MIN(_width - x, t_width); - tile->_height = MIN(_height - y, t_height); + tile->_width = MIN(_width - x, tWidth); + tile->_height = MIN(_height - y, tHeight); tile->_dataSize = 0; tile->_isEmpty = false; @@ -235,12 +234,12 @@ int IVIBandDesc::ivi_init_tiles(IVITile *ref_tile, int p, int b, int t_height, i tile->_refMbs = 0; if (p || b) { - if (tile->_numMBs != ref_tile->_numMBs) { - warning("ref_tile mismatch"); + if (tile->_numMBs != refTile->_numMBs) { + warning("refTile mismatch"); return -1; } - tile->_refMbs = ref_tile->_mbs; - ref_tile++; + tile->_refMbs = refTile->_mbs; + refTile++; } tile++; } @@ -267,15 +266,15 @@ bool IVIPicConfig::ivi_pic_config_cmp(const IVIPicConfig &cfg2) { IVIPlaneDesc::IVIPlaneDesc() : _width(0), _height(0), _numBands(0), _bands(nullptr) { } -int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool _isIndeo4) { +int IVIPlaneDesc::initPlanes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool isIndeo4) { int p, b; uint32 b_width, b_height, align_fac, width_aligned, - height_aligned, buf_size; + height_aligned, bufSize; IVIBandDesc *band; - ivi_free_buffers(planes); + freeBuffers(planes); - if (av_image_check_size(cfg->_picWidth, cfg->_picHeight, 0, NULL) < 0 || + if (checkImageSize(cfg->_picWidth, cfg->_picHeight, 0) < 0 || cfg->_lumaBands < 1 || cfg->_chromaBands < 1) return -1; @@ -307,7 +306,7 @@ int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *c align_fac = p ? 8 : 16; width_aligned = FFALIGN(b_width, align_fac); height_aligned = FFALIGN(b_height, align_fac); - buf_size = width_aligned * height_aligned * sizeof(int16); + bufSize = width_aligned * height_aligned * sizeof(int16); for (b = 0; b < planes[p]._numBands; b++) { band = &planes[p]._bands[b]; // select appropriate _plane/band @@ -317,20 +316,20 @@ int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *c band->_height = b_height; band->_pitch = width_aligned; band->_aHeight = height_aligned; - band->_bufs[0] = (int16 *)av_mallocz(buf_size); - band->_bufs[1] = (int16 *)av_mallocz(buf_size); - band->_bufSize = buf_size / 2; + band->_bufs[0] = (int16 *)av_mallocz(bufSize); + band->_bufs[1] = (int16 *)av_mallocz(bufSize); + band->_bufSize = bufSize / 2; if (!band->_bufs[0] || !band->_bufs[1]) return -2; // allocate the 3rd band buffer for scalability mode if (cfg->_lumaBands > 1) { - band->_bufs[2] = (int16 *)av_mallocz(buf_size); + band->_bufs[2] = (int16 *)av_mallocz(bufSize); if (!band->_bufs[2]) return -2; } - if (_isIndeo4) { - band->_bufs[3] = (int16 *)av_mallocz(buf_size); + if (isIndeo4) { + band->_bufs[3] = (int16 *)av_mallocz(bufSize); if (!band->_bufs[3]) return -2; } @@ -342,27 +341,26 @@ int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *c return 0; } -int IVIPlaneDesc::ff_ivi_init_tiles(IVIPlaneDesc *planes, - int _tileWidth, int _tileHeight) { - int p, b, x_tiles, y_tiles, t_width, t_height, ret; +int IVIPlaneDesc::initTiles(IVIPlaneDesc *planes, int tileWidth, int tileHeight) { + int p, b, xTiles, yTiles, tWidth, tHeight, ret; IVIBandDesc *band; for (p = 0; p < 3; p++) { - t_width = !p ? _tileWidth : (_tileWidth + 3) >> 2; - t_height = !p ? _tileHeight : (_tileHeight + 3) >> 2; + tWidth = !p ? tileWidth : (tileWidth + 3) >> 2; + tHeight = !p ? tileHeight : (tileHeight + 3) >> 2; if (!p && planes[0]._numBands == 4) { - t_width >>= 1; - t_height >>= 1; + tWidth >>= 1; + tHeight >>= 1; } - if (t_width <= 0 || t_height <= 0) + if (tWidth <= 0 || tHeight <= 0) return -3; for (b = 0; b < planes[p]._numBands; b++) { band = &planes[p]._bands[b]; - x_tiles = IVI_NUM_TILES(band->_width, t_width); - y_tiles = IVI_NUM_TILES(band->_height, t_height); - band->_numTiles = x_tiles * y_tiles; + xTiles = IVI_NUM_TILES(band->_width, tWidth); + yTiles = IVI_NUM_TILES(band->_height, tHeight); + band->_numTiles = xTiles * yTiles; av_freep(&band->_tiles); band->_tiles = (IVITile *)av_mallocz_array(band->_numTiles, sizeof(IVITile)); @@ -371,8 +369,8 @@ int IVIPlaneDesc::ff_ivi_init_tiles(IVIPlaneDesc *planes, // use the first luma band as reference for motion vectors // and quant - ret = band->ivi_init_tiles(planes[0]._bands[0]._tiles, - p, b, t_height, t_width); + ret = band->initTiles(planes[0]._bands[0]._tiles, + p, b, tHeight, tWidth); if (ret < 0) return ret; } @@ -381,7 +379,7 @@ int IVIPlaneDesc::ff_ivi_init_tiles(IVIPlaneDesc *planes, return 0; } -void IVIPlaneDesc::ivi_free_buffers(IVIPlaneDesc *planes) { +void IVIPlaneDesc::freeBuffers(IVIPlaneDesc *planes) { int p, b, t; for (p = 0; p < 3; p++) { @@ -403,6 +401,13 @@ void IVIPlaneDesc::ivi_free_buffers(IVIPlaneDesc *planes) { } } +int IVIPlaneDesc::checkImageSize(unsigned int w, unsigned int h, int log_offset) { + if (((w + 128) * (uint64)(h + 128)) < (MAX_INTEGER / 8)) + return 0; + + error("Picture size %ux%u is invalid", w, h); +} + /*------------------------------------------------------------------------*/ AVFrame::AVFrame() { @@ -410,7 +415,7 @@ AVFrame::AVFrame() { Common::fill(&_linesize[0], &_linesize[AV_NUM_DATA_POINTERS], 0); } -int AVFrame::ff_set_dimensions(uint16 width, uint16 height) { +int AVFrame::setDimensions(uint16 width, uint16 height) { _width = width; _height = height; _linesize[0] = _linesize[1] = _linesize[2] = width; @@ -418,8 +423,8 @@ int AVFrame::ff_set_dimensions(uint16 width, uint16 height) { return 0; } -int AVFrame::ff_get_buffer(int flags) { - av_frame_free(); +int AVFrame::getBuffer(int flags) { + freeFrame(); // Luminance channel _data[0] = (uint8 *)av_mallocz(_width * _height); @@ -433,7 +438,7 @@ int AVFrame::ff_get_buffer(int flags) { return 0; } -void AVFrame::av_frame_free() { +void AVFrame::freeFrame() { av_freep(&_data[0]); av_freep(&_data[1]); av_freep(&_data[2]); @@ -458,27 +463,27 @@ IVI45DecContext::IVI45DecContext() : _gb(nullptr), _frameNum(0), _frameType(0), for (int i = 0; i < 8; i++) { _iviMbVlcTabs[i]._table = _tableData + i * 2 * 8192; _iviMbVlcTabs[i]._table_allocated = 8192; - ivi_mb_huff_desc[i].ivi_create_huff_from_desc(&_iviMbVlcTabs[i], 1); + ivi_mb_huff_desc[i].createHuffFromDesc(&_iviMbVlcTabs[i], true); _iviBlkVlcTabs[i]._table = _tableData + (i * 2 + 1) * 8192; _iviBlkVlcTabs[i]._table_allocated = 8192; - ivi_blk_huff_desc[i].ivi_create_huff_from_desc(&_iviBlkVlcTabs[i], 1); + ivi_blk_huff_desc[i].createHuffFromDesc(&_iviBlkVlcTabs[i], true); } } /*------------------------------------------------------------------------*/ -IndeoDecoderBase::IndeoDecoderBase(uint16 _width, uint16 _height) : Codec() { +IndeoDecoderBase::IndeoDecoderBase(uint16 width, uint16 height) : Codec() { _pixelFormat = g_system->getScreenFormat(); assert(_pixelFormat.bytesPerPixel > 1); _surface = new Graphics::ManagedSurface(); - _surface->create(_width, _height, _pixelFormat); - _surface->fillRect(Common::Rect(0, 0, _width, _height), 0); + _surface->create(width, height, _pixelFormat); + _surface->fillRect(Common::Rect(0, 0, width, height), 0); _ctx._bRefBuf = 3; // buffer 2 is used for scalability mode } IndeoDecoderBase::~IndeoDecoderBase() { delete _surface; - IVIPlaneDesc::ivi_free_buffers(_ctx._planes); + IVIPlaneDesc::freeBuffers(_ctx._planes); if (_ctx._mbVlc._custTab._table) _ctx._mbVlc._custTab.ff_free_vlc(); @@ -512,11 +517,11 @@ int IndeoDecoderBase::decodeIndeoFrame() { return -1; } - switch_buffers(); + switchBuffers(); //{ START_TIMER; - if (is_nonnull_frame()) { + if (isNonNullFrame()) { _ctx._bufInvalid[_ctx._dstBuf] = 1; for (p = 0; p < 3; p++) { for (b = 0; b < _ctx._planes[p]._numBands; b++) { @@ -542,28 +547,28 @@ int IndeoDecoderBase::decodeIndeoFrame() { //STOP_TIMER("decode_planes"); } - if (!is_nonnull_frame()) + if (!isNonNullFrame()) return 0; assert(_ctx._planes[0]._width <= _surface->w && _ctx._planes[0]._height <= _surface->h); - result = frame->ff_set_dimensions(_ctx._planes[0]._width, _ctx._planes[0]._height); + result = frame->setDimensions(_ctx._planes[0]._width, _ctx._planes[0]._height); if (result < 0) return result; - if ((result = frame->ff_get_buffer(0)) < 0) + if ((result = frame->getBuffer(0)) < 0) return result; if (_ctx._isScalable) { if (_ctx._isIndeo4) - ff_ivi_recompose_haar(&_ctx._planes[0], frame->_data[0], frame->_linesize[0]); + recomposeHaar(&_ctx._planes[0], frame->_data[0], frame->_linesize[0]); else - ff_ivi_recompose53(&_ctx._planes[0], frame->_data[0], frame->_linesize[0]); + recompose53(&_ctx._planes[0], frame->_data[0], frame->_linesize[0]); } else { - ivi_output_plane(&_ctx._planes[0], frame->_data[0], frame->_linesize[0]); + outputPlane(&_ctx._planes[0], frame->_data[0], frame->_linesize[0]); } - ivi_output_plane(&_ctx._planes[2], frame->_data[1], frame->_linesize[1]); - ivi_output_plane(&_ctx._planes[1], frame->_data[2], frame->_linesize[2]); + outputPlane(&_ctx._planes[2], frame->_data[1], frame->_linesize[1]); + outputPlane(&_ctx._planes[1], frame->_data[2], frame->_linesize[2]); // If the bidirectional mode is enabled, next I and the following P // frame will be sent together. Unfortunately the approach below seems @@ -592,7 +597,7 @@ int IndeoDecoderBase::decodeIndeoFrame() { frame->_width, frame->_width); // Free the now un-needed frame data - frame->av_frame_free(); + frame->freeFrame(); return 0; } @@ -615,7 +620,7 @@ int IndeoDecoderBase::decode_band(IVIBandDesc *band) { } band->_dataPtr = _ctx._frameData + (_ctx._gb->getBitsCount() >> 3); - result = decode_band_hdr(band); + result = decodeBandHeader(band); if (result) { warning("Error while decoding band header: %d", result); @@ -653,24 +658,24 @@ int IndeoDecoderBase::decode_band(IVIBandDesc *band) { } tile->_isEmpty = _ctx._gb->getBits1(); if (tile->_isEmpty) { - result = ivi_process_empty_tile(band, tile, + result = processEmptyTile(band, tile, (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3)); if (result < 0) break; warning("Empty tile encountered!"); } else { - tile->_dataSize = ivi_dec_tile_data_size(_ctx._gb); + tile->_dataSize = decodeTileDataSize(_ctx._gb); if (!tile->_dataSize) { warning("Tile data size is zero!"); result = -1; break; } - result = decode_mb_info(band, tile); + result = decodeMbInfo(band, tile); if (result < 0) break; - result = ivi_decode_blocks(_ctx._gb, band, tile); + result = decodeBlocks(_ctx._gb, band, tile); if (result < 0) { warning("Corrupted tile data encountered!"); break; @@ -704,28 +709,28 @@ int IndeoDecoderBase::decode_band(IVIBandDesc *band) { return result; } -void IndeoDecoderBase::ff_ivi_recompose_haar(const IVIPlaneDesc *_plane, - uint8 *dst, const int dst_pitch) { +void IndeoDecoderBase::recomposeHaar(const IVIPlaneDesc *_plane, + uint8 *dst, const int dstPitch) { int x, y, indx, b0, b1, b2, b3, p0, p1, p2, p3; - const short * b0_ptr, *b1_ptr, *b2_ptr, *b3_ptr; + const short * b0Ptr, *b1Ptr, *b2Ptr, *b3Ptr; int32 _pitch; // all bands should have the same _pitch _pitch = _plane->_bands[0]._pitch; // get pointers to the wavelet bands - b0_ptr = _plane->_bands[0]._buf; - b1_ptr = _plane->_bands[1]._buf; - b2_ptr = _plane->_bands[2]._buf; - b3_ptr = _plane->_bands[3]._buf; + b0Ptr = _plane->_bands[0]._buf; + b1Ptr = _plane->_bands[1]._buf; + b2Ptr = _plane->_bands[2]._buf; + b3Ptr = _plane->_bands[3]._buf; for (y = 0; y < _plane->_height; y += 2) { for (x = 0, indx = 0; x < _plane->_width; x += 2, indx++) { // load coefficients - b0 = b0_ptr[indx]; //should be: b0 = (_numBands > 0) ? b0_ptr[indx] : 0; - b1 = b1_ptr[indx]; //should be: b1 = (_numBands > 1) ? b1_ptr[indx] : 0; - b2 = b2_ptr[indx]; //should be: b2 = (_numBands > 2) ? b2_ptr[indx] : 0; - b3 = b3_ptr[indx]; //should be: b3 = (_numBands > 3) ? b3_ptr[indx] : 0; + b0 = b0Ptr[indx]; //should be: b0 = (_numBands > 0) ? b0Ptr[indx] : 0; + b1 = b1Ptr[indx]; //should be: b1 = (_numBands > 1) ? b1Ptr[indx] : 0; + b2 = b2Ptr[indx]; //should be: b2 = (_numBands > 2) ? b2Ptr[indx] : 0; + b3 = b3Ptr[indx]; //should be: b3 = (_numBands > 3) ? b3Ptr[indx] : 0; // haar wavelet recomposition p0 = (b0 + b1 + b2 + b3 + 2) >> 2; @@ -736,28 +741,27 @@ void IndeoDecoderBase::ff_ivi_recompose_haar(const IVIPlaneDesc *_plane, // bias, convert and output four pixels dst[x] = av_clip_uint8(p0 + 128); dst[x + 1] = av_clip_uint8(p1 + 128); - dst[dst_pitch + x] = av_clip_uint8(p2 + 128); - dst[dst_pitch + x + 1] = av_clip_uint8(p3 + 128); + dst[dstPitch + x] = av_clip_uint8(p2 + 128); + dst[dstPitch + x + 1] = av_clip_uint8(p3 + 128); }// for x - dst += dst_pitch << 1; + dst += dstPitch << 1; - b0_ptr += _pitch; - b1_ptr += _pitch; - b2_ptr += _pitch; - b3_ptr += _pitch; + b0Ptr += _pitch; + b1Ptr += _pitch; + b2Ptr += _pitch; + b3Ptr += _pitch; }// for y } - -void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, - uint8 *dst, const int dst_pitch) { +void IndeoDecoderBase::recompose53(const IVIPlaneDesc *_plane, + uint8 *dst, const int dstPitch) { int x, y, indx; int32 p0, p1, p2, p3, tmp0, tmp1, tmp2; int32 b0_1, b0_2, b1_1, b1_2, b1_3, b2_1, b2_2, b2_3, b2_4, b2_5, b2_6; int32 b3_1, b3_2, b3_3, b3_4, b3_5, b3_6, b3_7, b3_8, b3_9; int32 _pitch, back_pitch; - const short * b0_ptr, *b1_ptr, *b2_ptr, *b3_ptr; + const short * b0Ptr, *b1Ptr, *b2Ptr, *b3Ptr; const int _numBands = 4; // all bands should have the same _pitch @@ -767,10 +771,10 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, back_pitch = 0; // get pointers to the wavelet bands - b0_ptr = _plane->_bands[0]._buf; - b1_ptr = _plane->_bands[1]._buf; - b2_ptr = _plane->_bands[2]._buf; - b3_ptr = _plane->_bands[3]._buf; + b0Ptr = _plane->_bands[0]._buf; + b1Ptr = _plane->_bands[1]._buf; + b2Ptr = _plane->_bands[2]._buf; + b3Ptr = _plane->_bands[3]._buf; for (y = 0; y < _plane->_height; y += 2) { @@ -778,38 +782,38 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, _pitch = 0; // load storage variables with values if (_numBands > 0) { - b0_1 = b0_ptr[0]; - b0_2 = b0_ptr[_pitch]; + b0_1 = b0Ptr[0]; + b0_2 = b0Ptr[_pitch]; } if (_numBands > 1) { - b1_1 = b1_ptr[back_pitch]; - b1_2 = b1_ptr[0]; - b1_3 = b1_1 - b1_2 * 6 + b1_ptr[_pitch]; + b1_1 = b1Ptr[back_pitch]; + b1_2 = b1Ptr[0]; + b1_3 = b1_1 - b1_2 * 6 + b1Ptr[_pitch]; } if (_numBands > 2) { - b2_2 = b2_ptr[0]; // b2[x, y ] - b2_3 = b2_2; // b2[x+1,y ] = b2[x,y] - b2_5 = b2_ptr[_pitch]; // b2[x ,y+1] - b2_6 = b2_5; // b2[x+1,y+1] = b2[x,y+1] + b2_2 = b2Ptr[0]; // b2[x, y ] + b2_3 = b2_2; // b2[x+1,y ] = b2[x,y] + b2_5 = b2Ptr[_pitch]; // b2[x ,y+1] + b2_6 = b2_5; // b2[x+1,y+1] = b2[x,y+1] } if (_numBands > 3) { - b3_2 = b3_ptr[back_pitch]; // b3[x ,y-1] - b3_3 = b3_2; // b3[x+1,y-1] = b3[x ,y-1] - b3_5 = b3_ptr[0]; // b3[x ,y ] - b3_6 = b3_5; // b3[x+1,y ] = b3[x ,y ] - b3_8 = b3_2 - b3_5 * 6 + b3_ptr[_pitch]; + b3_2 = b3Ptr[back_pitch]; // b3[x ,y-1] + b3_3 = b3_2; // b3[x+1,y-1] = b3[x ,y-1] + b3_5 = b3Ptr[0]; // b3[x ,y ] + b3_6 = b3_5; // b3[x+1,y ] = b3[x ,y ] + b3_8 = b3_2 - b3_5 * 6 + b3Ptr[_pitch]; b3_9 = b3_8; } for (x = 0, indx = 0; x < _plane->_width; x += 2, indx++) { if (x + 2 >= _plane->_width) { - b0_ptr--; - b1_ptr--; - b2_ptr--; - b3_ptr--; + b0Ptr--; + b1Ptr--; + b2Ptr--; + b3Ptr--; } // some values calculated in the previous iterations can @@ -831,8 +835,8 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, if (_numBands > 0) { tmp0 = b0_1; tmp2 = b0_2; - b0_1 = b0_ptr[indx + 1]; - b0_2 = b0_ptr[_pitch + indx + 1]; + b0_1 = b0Ptr[indx + 1]; + b0_2 = b0Ptr[_pitch + indx + 1]; tmp1 = tmp0 + b0_1; p0 = tmp0 << 4; @@ -845,11 +849,11 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, if (_numBands > 1) { tmp0 = b1_2; tmp1 = b1_1; - b1_2 = b1_ptr[indx + 1]; - b1_1 = b1_ptr[back_pitch + indx + 1]; + b1_2 = b1Ptr[indx + 1]; + b1_1 = b1Ptr[back_pitch + indx + 1]; tmp2 = tmp1 - tmp0 * 6 + b1_3; - b1_3 = b1_1 - b1_2 * 6 + b1_ptr[_pitch + indx + 1]; + b1_3 = b1_1 - b1_2 * 6 + b1Ptr[_pitch + indx + 1]; p0 += (tmp0 + tmp1) << 3; p1 += (tmp0 + tmp1 + b1_1 + b1_2) << 2; @@ -859,8 +863,8 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, // process the LH-band by applying LPF vertically and HPF horizontally if (_numBands > 2) { - b2_3 = b2_ptr[indx + 1]; - b2_6 = b2_ptr[_pitch + indx + 1]; + b2_3 = b2Ptr[indx + 1]; + b2_6 = b2Ptr[_pitch + indx + 1]; tmp0 = b2_1 + b2_2; tmp1 = b2_1 - b2_2 * 6 + b2_3; @@ -873,14 +877,14 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, // process the HH-band by applying HPF both vertically and horizontally if (_numBands > 3) { - b3_6 = b3_ptr[indx + 1]; // b3[x+1,y ] - b3_3 = b3_ptr[back_pitch + indx + 1]; // b3[x+1,y-1] + b3_6 = b3Ptr[indx + 1]; // b3[x+1,y ] + b3_3 = b3Ptr[back_pitch + indx + 1]; // b3[x+1,y-1] tmp0 = b3_1 + b3_4; tmp1 = b3_2 + b3_5; tmp2 = b3_3 + b3_6; - b3_9 = b3_3 - b3_6 * 6 + b3_ptr[_pitch + indx + 1]; + b3_9 = b3_3 - b3_6 * 6 + b3Ptr[_pitch + indx + 1]; p0 += (tmp0 + tmp1) << 2; p1 += (tmp0 - tmp1 * 6 + tmp2) << 1; @@ -891,25 +895,25 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, // output four pixels dst[x] = av_clip_uint8((p0 >> 6) + 128); dst[x + 1] = av_clip_uint8((p1 >> 6) + 128); - dst[dst_pitch + x] = av_clip_uint8((p2 >> 6) + 128); - dst[dst_pitch + x + 1] = av_clip_uint8((p3 >> 6) + 128); + dst[dstPitch + x] = av_clip_uint8((p2 >> 6) + 128); + dst[dstPitch + x + 1] = av_clip_uint8((p3 >> 6) + 128); }// for x - dst += dst_pitch << 1; + dst += dstPitch << 1; back_pitch = -_pitch; - b0_ptr += _pitch + 1; - b1_ptr += _pitch + 1; - b2_ptr += _pitch + 1; - b3_ptr += _pitch + 1; + b0Ptr += _pitch + 1; + b1Ptr += _pitch + 1; + b2Ptr += _pitch + 1; + b3Ptr += _pitch + 1; } } -void IndeoDecoderBase::ivi_output_plane(IVIPlaneDesc *_plane, uint8 *dst, int dst_pitch) { +void IndeoDecoderBase::outputPlane(IVIPlaneDesc *_plane, uint8 *dst, int dstPitch) { int x, y; const int16 * src = _plane->_bands[0]._buf; - uint32 _pitch = _plane->_bands[0]._pitch; + uint32 pitch = _plane->_bands[0]._pitch; if (!src) return; @@ -917,40 +921,40 @@ void IndeoDecoderBase::ivi_output_plane(IVIPlaneDesc *_plane, uint8 *dst, int ds for (y = 0; y < _plane->_height; y++) { for (x = 0; x < _plane->_width; x++) dst[x] = av_clip_uint8(src[x] + 128); - src += _pitch; - dst += dst_pitch; + src += pitch; + dst += dstPitch; } } -int IndeoDecoderBase::ivi_process_empty_tile(IVIBandDesc *band, - IVITile *tile, int32 mv_scale) { - int x, y, need_mc, mbn, blk, num_blocks, _mvX, _mvY, mc_type; - int offs, mb_offset, row_offset, ret; - IVIMbInfo *mb, *ref_mb; +int IndeoDecoderBase::processEmptyTile(IVIBandDesc *band, + IVITile *tile, int32 mvScale) { + int x, y, needMc, mbn, blk, numBlocks, mvX, mvY, mcType; + int offs, mbOffset, rowOffset, ret; + IVIMbInfo *mb, *refMb; const int16 * src; int16 * dst; - IviMCFunc mc_no_delta_func; + IviMCFunc mcNoDeltaFunc; if (tile->_numMBs != IVI_MBs_PER_TILE(tile->_width, tile->_height, band->_mbSize)) { warning("Allocated tile size %d mismatches " - "parameters %d in ivi_process_empty_tile()", + "parameters %d in processEmptyTile()", tile->_numMBs, IVI_MBs_PER_TILE(tile->_width, tile->_height, band->_mbSize)); return -1; } offs = tile->_yPos * band->_pitch + tile->_xPos; mb = tile->_mbs; - ref_mb = tile->_refMbs; - row_offset = band->_mbSize * band->_pitch; - need_mc = 0; // reset the mc tracking flag + refMb = tile->_refMbs; + rowOffset = band->_mbSize * band->_pitch; + needMc = 0; // reset the mc tracking flag for (y = tile->_yPos; y < (tile->_yPos + tile->_height); y += band->_mbSize) { - mb_offset = offs; + mbOffset = offs; for (x = tile->_xPos; x < (tile->_xPos + tile->_width); x += band->_mbSize) { mb->_xPos = x; mb->_yPos = y; - mb->_bufOffs = mb_offset; + mb->_bufOffs = mbOffset; mb->_type = 1; // set the macroblocks _type = INTER mb->_cbp = 0; // all blocks are empty @@ -961,19 +965,19 @@ int IndeoDecoderBase::ivi_process_empty_tile(IVIBandDesc *band, mb->_mvY = 0; } - if (band->_inheritQDelta && ref_mb) - mb->_qDelta = ref_mb->_qDelta; + if (band->_inheritQDelta && refMb) + mb->_qDelta = refMb->_qDelta; - if (band->_inheritMv && ref_mb) { + if (band->_inheritMv && refMb) { // motion vector inheritance - if (mv_scale) { - mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); - mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); + if (mvScale) { + mb->_mvX = scaleMV(refMb->_mvX, mvScale); + mb->_mvY = scaleMV(refMb->_mvY, mvScale); } else { - mb->_mvX = ref_mb->_mvX; - mb->_mvY = ref_mb->_mvY; + mb->_mvX = refMb->_mvX; + mb->_mvY = refMb->_mvY; } - need_mc |= mb->_mvX || mb->_mvY; // tracking non-zero motion vectors + needMc |= mb->_mvX || mb->_mvY; // tracking non-zero motion vectors { int dmv_x, dmv_y, cx, cy; @@ -993,34 +997,34 @@ int IndeoDecoderBase::ivi_process_empty_tile(IVIBandDesc *band, } mb++; - if (ref_mb) - ref_mb++; - mb_offset += band->_mbSize; + if (refMb) + refMb++; + mbOffset += band->_mbSize; } // for x - offs += row_offset; + offs += rowOffset; } // for y - if (band->_inheritMv && need_mc) { // apply motion compensation if there is at least one non-zero motion vector - num_blocks = (band->_mbSize != band->_blkSize) ? 4 : 1; // number of blocks per mb - mc_no_delta_func = (band->_blkSize == 8) ? IndeoDSP::ff_ivi_mc_8x8_no_delta + if (band->_inheritMv && needMc) { // apply motion compensation if there is at least one non-zero motion vector + numBlocks = (band->_mbSize != band->_blkSize) ? 4 : 1; // number of blocks per mb + mcNoDeltaFunc = (band->_blkSize == 8) ? IndeoDSP::ff_ivi_mc_8x8_no_delta : IndeoDSP::ff_ivi_mc_4x4_no_delta; for (mbn = 0, mb = tile->_mbs; mbn < tile->_numMBs; mb++, mbn++) { - _mvX = mb->_mvX; - _mvY = mb->_mvY; + mvX = mb->_mvX; + mvY = mb->_mvY; if (!band->_isHalfpel) { - mc_type = 0; // we have only fullpel vectors + mcType = 0; // we have only fullpel vectors } else { - mc_type = ((_mvY & 1) << 1) | (_mvX & 1); - _mvX >>= 1; - _mvY >>= 1; // convert halfpel vectors into fullpel ones + mcType = ((mvY & 1) << 1) | (mvX & 1); + mvX >>= 1; + mvY >>= 1; // convert halfpel vectors into fullpel ones } - for (blk = 0; blk < num_blocks; blk++) { + for (blk = 0; blk < numBlocks; blk++) { // adjust block position in the buffer according with its number offs = mb->_bufOffs + band->_blkSize * ((blk & 1) + !!(blk & 2) * band->_pitch); - ret = ivi_mc(band, mc_no_delta_func, nullptr, offs, - _mvX, _mvY, 0, 0, mc_type, -1); + ret = iviMc(band, mcNoDeltaFunc, nullptr, offs, + mvX, mvY, 0, 0, mcType, -1); if (ret < 0) return ret; } @@ -1039,53 +1043,53 @@ int IndeoDecoderBase::ivi_process_empty_tile(IVIBandDesc *band, return 0; } -int IndeoDecoderBase::ivi_dec_tile_data_size(GetBits *_gb) { +int IndeoDecoderBase::decodeTileDataSize(GetBits *gb) { int len = 0; - if (_gb->getBits1()) { - len = _gb->getBits(8); + if (gb->getBits1()) { + len = gb->getBits(8); if (len == 255) - len = _gb->getBitsLong(24); + len = gb->getBitsLong(24); } // align the bitstream reader on the byte boundary - _gb->alignGetBits(); + gb->alignGetBits(); return len; } -int IndeoDecoderBase::ivi_decode_blocks(GetBits *_gb, IVIBandDesc *band, IVITile *tile) { - int mbn, blk, num_blocks, _blkSize, ret, is_intra; - int mc_type = 0, mc_type2 = -1; - int _mvX = 0, _mvY = 0, mv_x2 = 0, mv_y2 = 0; - int32 prev_dc; - uint32 _cbp, quant, _bufOffs; +int IndeoDecoderBase::decodeBlocks(GetBits *_gb, IVIBandDesc *band, IVITile *tile) { + int mbn, blk, numBlocks, blkSize, ret, isIntra; + int mcType = 0, mcType2 = -1; + int mvX = 0, mvY = 0, mvX2 = 0, mvY2 = 0; + int32 prevDc; + uint32 cbp, quant, bufOffs; IVIMbInfo *mb; - IviMCFunc mc_with_delta_func, mc_no_delta_func; - IviMCAvgFunc mc_avg_with_delta_func, mc_avg_no_delta_func; - const uint8 *scale_tab; + IviMCFunc mcWithDeltaFunc, mcNoDeltaFunc; + IviMCAvgFunc mcAvgWithDeltaFunc, mcAvgNoDeltaFunc; + const uint8 *scaleTab; // init intra prediction for the DC coefficient - prev_dc = 0; - _blkSize = band->_blkSize; + prevDc = 0; + blkSize = band->_blkSize; // number of blocks per mb - num_blocks = (band->_mbSize != _blkSize) ? 4 : 1; - if (_blkSize == 8) { - mc_with_delta_func = IndeoDSP::ff_ivi_mc_8x8_delta; - mc_no_delta_func = IndeoDSP::ff_ivi_mc_8x8_no_delta; - mc_avg_with_delta_func = IndeoDSP::ff_ivi_mc_avg_8x8_delta; - mc_avg_no_delta_func = IndeoDSP::ff_ivi_mc_avg_8x8_no_delta; + numBlocks = (band->_mbSize != blkSize) ? 4 : 1; + if (blkSize == 8) { + mcWithDeltaFunc = IndeoDSP::ff_ivi_mc_8x8_delta; + mcNoDeltaFunc = IndeoDSP::ff_ivi_mc_8x8_no_delta; + mcAvgWithDeltaFunc = IndeoDSP::ff_ivi_mc_avg_8x8_delta; + mcAvgNoDeltaFunc = IndeoDSP::ff_ivi_mc_avg_8x8_no_delta; } else { - mc_with_delta_func = IndeoDSP::ff_ivi_mc_4x4_delta; - mc_no_delta_func = IndeoDSP::ff_ivi_mc_4x4_no_delta; - mc_avg_with_delta_func = IndeoDSP::ff_ivi_mc_avg_4x4_delta; - mc_avg_no_delta_func = IndeoDSP::ff_ivi_mc_avg_4x4_no_delta; + mcWithDeltaFunc = IndeoDSP::ff_ivi_mc_4x4_delta; + mcNoDeltaFunc = IndeoDSP::ff_ivi_mc_4x4_no_delta; + mcAvgWithDeltaFunc = IndeoDSP::ff_ivi_mc_avg_4x4_delta; + mcAvgNoDeltaFunc = IndeoDSP::ff_ivi_mc_avg_4x4_no_delta; } for (mbn = 0, mb = tile->_mbs; mbn < tile->_numMBs; mb++, mbn++) { - is_intra = !mb->_type; - _cbp = mb->_cbp; - _bufOffs = mb->_bufOffs; + isIntra = !mb->_type; + cbp = mb->_cbp; + bufOffs = mb->_bufOffs; quant = band->_globQuant + mb->_qDelta; if (_ctx._isIndeo4) @@ -1093,27 +1097,27 @@ int IndeoDecoderBase::ivi_decode_blocks(GetBits *_gb, IVIBandDesc *band, IVITile else quant = av_clip((int)quant, 0, 23); - scale_tab = is_intra ? band->_intraScale : band->_interScale; - if (scale_tab) - quant = scale_tab[quant]; + scaleTab = isIntra ? band->_intraScale : band->_interScale; + if (scaleTab) + quant = scaleTab[quant]; - if (!is_intra) { - _mvX = mb->_mvX; - _mvY = mb->_mvY; - mv_x2 = mb->_bMvX; - mv_y2 = mb->_bMvY; + if (!isIntra) { + mvX = mb->_mvX; + mvY = mb->_mvY; + mvX2 = mb->_bMvX; + mvY2 = mb->_bMvY; if (band->_isHalfpel) { - mc_type = ((_mvY & 1) << 1) | (_mvX & 1); - mc_type2 = ((mv_y2 & 1) << 1) | (mv_x2 & 1); - _mvX >>= 1; - _mvY >>= 1; - mv_x2 >>= 1; - mv_y2 >>= 1; // convert halfpel vectors into fullpel ones + mcType = ((mvY & 1) << 1) | (mvX & 1); + mcType2 = ((mvY2 & 1) << 1) | (mvX2 & 1); + mvX >>= 1; + mvY >>= 1; + mvX2 >>= 1; + mvY2 >>= 1; // convert halfpel vectors into fullpel ones } if (mb->_type == 2) - mc_type = -1; + mcType = -1; if (mb->_type != 2 && mb->_type != 3) - mc_type2 = -1; + mcType2 = -1; if (mb->_type) { int dmv_x, dmv_y, cx, cy; @@ -1146,42 +1150,42 @@ int IndeoDecoderBase::ivi_decode_blocks(GetBits *_gb, IVIBandDesc *band, IVITile } } - for (blk = 0; blk < num_blocks; blk++) { + for (blk = 0; blk < numBlocks; blk++) { // adjust block position in the buffer according to its number if (blk & 1) { - _bufOffs += _blkSize; + bufOffs += blkSize; } else if (blk == 2) { - _bufOffs -= _blkSize; - _bufOffs += _blkSize * band->_pitch; + bufOffs -= blkSize; + bufOffs += blkSize * band->_pitch; } - if (_cbp & 1) { // block coded ? - ret = ivi_decode_coded_blocks(_gb, band, mc_with_delta_func, - mc_avg_with_delta_func, - _mvX, _mvY, mv_x2, mv_y2, - &prev_dc, is_intra, - mc_type, mc_type2, quant, - _bufOffs); + if (cbp & 1) { // block coded ? + ret = ivi_decode_coded_blocks(_gb, band, mcWithDeltaFunc, + mcAvgWithDeltaFunc, + mvX, mvY, mvX2, mvY2, + &prevDc, isIntra, + mcType, mcType2, quant, + bufOffs); if (ret < 0) return ret; } else { // block not coded // for intra blocks apply the dc slant transform // for inter - perform the motion compensation without delta - if (is_intra) { - ret = ivi_dc_transform(band, &prev_dc, _bufOffs, _blkSize); + if (isIntra) { + ret = ivi_dc_transform(band, &prevDc, bufOffs, blkSize); if (ret < 0) return ret; } else { - ret = ivi_mc(band, mc_no_delta_func, mc_avg_no_delta_func, - _bufOffs, _mvX, _mvY, mv_x2, mv_y2, - mc_type, mc_type2); + ret = iviMc(band, mcNoDeltaFunc, mcAvgNoDeltaFunc, + bufOffs, mvX, mvY, mvX2, mvY2, + mcType, mcType2); if (ret < 0) return ret; } } - _cbp >>= 1; + cbp >>= 1; }// for blk }// for mbn @@ -1189,66 +1193,66 @@ int IndeoDecoderBase::ivi_decode_blocks(GetBits *_gb, IVIBandDesc *band, IVITile return 0; } -int IndeoDecoderBase::ivi_scale_mv(int mv, int mv_scale){ - return (mv + (mv > 0) + (mv_scale - 1)) >> mv_scale; +int IndeoDecoderBase::scaleMV(int mv, int mvScale) { + return (mv + (mv > 0) + (mvScale - 1)) >> mvScale; } -int IndeoDecoderBase::ivi_mc(IVIBandDesc *band, IviMCFunc mc, IviMCAvgFunc mc_avg, - int offs, int _mvX, int _mvY, int mv_x2, int mv_y2, - int mc_type, int mc_type2){ - int ref_offs = offs + _mvY * band->_pitch + _mvX; - int buf_size = band->_pitch * band->_aHeight; - int min_size = band->_pitch * (band->_blkSize - 1) + band->_blkSize; - int ref_size = (mc_type > 1) * band->_pitch + (mc_type & 1); - - if (mc_type != -1) { - assert(offs >= 0 && ref_offs >= 0 && band->_refBuf); - assert(buf_size - min_size >= offs); - assert(buf_size - min_size - ref_size >= ref_offs); +int IndeoDecoderBase::iviMc(IVIBandDesc *band, IviMCFunc mc, IviMCAvgFunc mcAvg, + int offs, int mvX, int mvY, int mvX2, int mvY2, + int mcType, int mcType2) { + int refOffs = offs + mvY * band->_pitch + mvX; + int bufSize = band->_pitch * band->_aHeight; + int minSize = band->_pitch * (band->_blkSize - 1) + band->_blkSize; + int refSize = (mcType > 1) * band->_pitch + (mcType & 1); + + if (mcType != -1) { + assert(offs >= 0 && refOffs >= 0 && band->_refBuf); + assert(bufSize - minSize >= offs); + assert(bufSize - minSize - refSize >= refOffs); } - if (mc_type2 == -1) { - mc(band->_buf + offs, band->_refBuf + ref_offs, band->_pitch, mc_type); + if (mcType2 == -1) { + mc(band->_buf + offs, band->_refBuf + refOffs, band->_pitch, mcType); } else { - int ref_offs2 = offs + mv_y2 * band->_pitch + mv_x2; - int ref_size2 = (mc_type2 > 1) * band->_pitch + (mc_type2 & 1); + int ref_offs2 = offs + mvY2 * band->_pitch + mvX2; + int ref_size2 = (mcType2 > 1) * band->_pitch + (mcType2 & 1); if (offs < 0 || ref_offs2 < 0 || !band->_bRefBuf) return -1; - if (buf_size - min_size - ref_size2 < ref_offs2) + if (bufSize - minSize - ref_size2 < ref_offs2) return -1; - if (mc_type == -1) + if (mcType == -1) mc(band->_buf + offs, band->_bRefBuf + ref_offs2, - band->_pitch, mc_type2); + band->_pitch, mcType2); else - mc_avg(band->_buf + offs, band->_refBuf + ref_offs, + mcAvg(band->_buf + offs, band->_refBuf + refOffs, band->_bRefBuf + ref_offs2, band->_pitch, - mc_type, mc_type2); + mcType, mcType2); } return 0; } -int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *_gb, IVIBandDesc *band, - IviMCFunc mc, IviMCAvgFunc mc_avg, int _mvX, int _mvY, - int mv_x2, int mv_y2, int *prev_dc, int is_intra, - int mc_type, int mc_type2, uint32 quant, int offs) { - const uint16 *base_tab = is_intra ? band->_intraBase : band->_interBase; +int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *gb, IVIBandDesc *band, + IviMCFunc mc, IviMCAvgFunc mcAvg, int mvX, int mvY, + int mvX2, int mvY2, int *prevDc, int isIntra, + int mcType, int mcType2, uint32 quant, int offs) { + const uint16 *base_tab = isIntra ? band->_intraBase : band->_interBase; RVMapDesc *rvmap = band->_rvMap; - uint8 col_flags[8]; + uint8 colFlags[8]; int32 trvec[64]; uint32 sym = 0, q; int lo, hi; int pos, run, val; - int _blkSize = band->_blkSize; - int num_coeffs = _blkSize * _blkSize; - int col_mask = _blkSize - 1; - int scan_pos = -1; - int min_size = band->_pitch * (band->_transformSize - 1) + + int blkSize = band->_blkSize; + int numCoeffs = blkSize * blkSize; + int colMask = blkSize - 1; + int scanPos = -1; + int minSize = band->_pitch * (band->_transformSize - 1) + band->_transformSize; - int buf_size = band->_pitch * band->_aHeight - offs; + int bufSize = band->_pitch * band->_aHeight - offs; - if (min_size > buf_size) + if (minSize > bufSize) return -1; if (!band->_scan) { @@ -1257,20 +1261,20 @@ int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *_gb, IVIBandDesc *band, } // zero transform vector - memset(trvec, 0, num_coeffs * sizeof(trvec[0])); + memset(trvec, 0, numCoeffs * sizeof(trvec[0])); // zero column flags - memset(col_flags, 0, sizeof(col_flags)); - while (scan_pos <= num_coeffs) { - sym = _gb->getVLC2(band->_blkVlc._tab->_table, + memset(colFlags, 0, sizeof(colFlags)); + while (scanPos <= numCoeffs) { + sym = gb->getVLC2(band->_blkVlc._tab->_table, IVI_VLC_BITS, 1); if (sym == rvmap->_eobSym) break; // End of block - // Escape - run/val explicitly coded using 3 vlc codes + // Escape - run/val explicitly coded using 3 vlc codes if (sym == rvmap->_escSym) { - run = _gb->getVLC2(band->_blkVlc._tab->_table, IVI_VLC_BITS, 1) + 1; - lo = _gb->getVLC2(band->_blkVlc._tab->_table, IVI_VLC_BITS, 1); - hi = _gb->getVLC2(band->_blkVlc._tab->_table, IVI_VLC_BITS, 1); + run = gb->getVLC2(band->_blkVlc._tab->_table, IVI_VLC_BITS, 1) + 1; + lo = gb->getVLC2(band->_blkVlc._tab->_table, IVI_VLC_BITS, 1); + hi = gb->getVLC2(band->_blkVlc._tab->_table, IVI_VLC_BITS, 1); // merge them and convert into signed val val = IVI_TOSIGNED((hi << 6) | lo); } else { @@ -1283,10 +1287,10 @@ int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *_gb, IVIBandDesc *band, } // de-zigzag and dequantize - scan_pos += run; - if (scan_pos >= num_coeffs || scan_pos < 0) + scanPos += run; + if (scanPos >= numCoeffs || scanPos < 0) break; - pos = band->_scan[scan_pos]; + pos = band->_scan[scanPos]; if (!val) warning("Val = 0 encountered!"); @@ -1296,17 +1300,17 @@ int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *_gb, IVIBandDesc *band, val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1); trvec[pos] = val; // track columns containing non-zero coeffs - col_flags[pos & col_mask] |= !!val; + colFlags[pos & colMask] |= !!val; } - if (scan_pos < 0 || (scan_pos >= num_coeffs && sym != rvmap->_eobSym)) + if (scanPos < 0 || (scanPos >= numCoeffs && sym != rvmap->_eobSym)) return -1; // corrupt block data // undoing DC coeff prediction for intra-blocks - if (is_intra && band->_is2dTrans) { - *prev_dc += trvec[0]; - trvec[0] = *prev_dc; - col_flags[0] |= !!*prev_dc; + if (isIntra && band->_is2dTrans) { + *prevDc += trvec[0]; + trvec[0] = *prevDc; + colFlags[0] |= !!*prevDc; } if (band->_transformSize > band->_blkSize) { @@ -1316,25 +1320,25 @@ int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *_gb, IVIBandDesc *band, // apply inverse transform band->_invTransform(trvec, band->_buf + offs, - band->_pitch, col_flags); + band->_pitch, colFlags); // apply motion compensation - if (!is_intra) - return ivi_mc(band, mc, mc_avg, offs, _mvX, _mvY, mv_x2, mv_y2, - mc_type, mc_type2); + if (!isIntra) + return iviMc(band, mc, mcAvg, offs, mvX, mvY, mvX2, mvY2, + mcType, mcType2); return 0; } -int IndeoDecoderBase::ivi_dc_transform(IVIBandDesc *band, int *prev_dc, +int IndeoDecoderBase::ivi_dc_transform(IVIBandDesc *band, int *prevDc, int bufOffs, int blkSize) { - int buf_size = band->_pitch * band->_aHeight - bufOffs; - int min_size = (blkSize - 1) * band->_pitch + blkSize; + int bufSize = band->_pitch * band->_aHeight - bufOffs; + int minSize = (blkSize - 1) * band->_pitch + blkSize; - if (min_size > buf_size) + if (minSize > bufSize) return -1; - band->_dcTransform(prev_dc, band->_buf + bufOffs, + band->_dcTransform(prevDc, band->_buf + bufOffs, band->_pitch, blkSize); return 0; @@ -1342,15 +1346,6 @@ int IndeoDecoderBase::ivi_dc_transform(IVIBandDesc *band, int *prev_dc, /*------------------------------------------------------------------------*/ -int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx) { - if (((w + 128) * (uint64)(h + 128)) < (MAX_INTEGER / 8)) - return 0; - - error("Picture size %ux%u is invalid", w, h); -} - -/*------------------------------------------------------------------------*/ - const uint8 IndeoDecoderBase::_ff_ivi_vertical_scan_8x8[64] = { 0, 8, 16, 24, 32, 40, 48, 56, 1, 9, 17, 25, 33, 41, 49, 57, diff --git a/image/codecs/indeo/indeo.h b/image/codecs/indeo/indeo.h index b9e46931b0..5f6d67f34f 100644 --- a/image/codecs/indeo/indeo.h +++ b/image/codecs/indeo/indeo.h @@ -66,7 +66,7 @@ enum { typedef void (InvTransformPtr)(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags); typedef void (DCTransformPtr) (const int32 *in, int16 *out, uint32 pitch, int blkSize); -typedef void(*IviMCFunc) (int16 *buf, const int16 *refBuf, uint32 pitch, int mc_type); +typedef void(*IviMCFunc) (int16 *buf, const int16 *refBuf, uint32 pitch, int mcType); typedef void(*IviMCAvgFunc) (int16 *buf, const int16 *refBuf1, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2); @@ -82,8 +82,8 @@ typedef void(*IviMCAvgFunc) (int16 *buf, const int16 *refBuf1, const int16 *refB /** * calculate number of macroblocks in a tile */ -#define IVI_MBs_PER_TILE(_tileWidth, _tileHeight, _mbSize) \ - ((((_tileWidth) + (_mbSize) - 1) / (_mbSize)) * (((_tileHeight) + (_mbSize) - 1) / (_mbSize))) +#define IVI_MBs_PER_TILE(tileWidth, tileHeight, mbSize) \ + ((((tileWidth) + (mbSize) - 1) / (mbSize)) * (((tileHeight) + (mbSize) - 1) / (mbSize))) /** * huffman codebook descriptor @@ -96,32 +96,32 @@ struct IVIHuffDesc { * Generate a huffman codebook from the given descriptor * and convert it into the FFmpeg VLC table. * - * @param[out] vlc where to place the generated VLC table - * @param[in] flag flag: 1 - for static or 0 for dynamic tables - * @return result code: 0 - OK, -1 = error (invalid codebook descriptor) + * @param[out] vlc Where to place the generated VLC table + * @param[in] flag Flag: true - for static or false for dynamic tables + * @returns result code: 0 - OK, -1 = error (invalid codebook descriptor) */ - int ivi_create_huff_from_desc(VLC *vlc, int flag) const; + int createHuffFromDesc(VLC *vlc, bool flag) const; /* * Compare two huffman codebook descriptors. * - * @param[in] desc2 ptr to the 2nd descriptor to compare - * @return comparison result: 0 - equal, 1 - not equal + * @param[in] desc2 Ptr to the 2nd descriptor to compare + * @returns comparison result: 0 - equal, 1 - not equal */ - bool ivi_huff_desc_cmp(const IVIHuffDesc *desc2) const; + bool huffDescCompare(const IVIHuffDesc *desc2) const; /* * Copy huffman codebook descriptors. * - * @param[in] src ptr to the source descriptor + * @param[in] src ptr to the source descriptor */ - void ivi_huff_desc_copy(const IVIHuffDesc *src); + void huffDescCopy(const IVIHuffDesc *src); }; struct IVI45DecContext; /** - * macroblock/block huffman table descriptor + * Macroblock/block huffman table descriptor */ struct IVIHuffTab { public: @@ -138,7 +138,16 @@ public: */ IVIHuffTab(); - int ff_ivi_dec_huff_desc(IVI45DecContext *ctx, int desc_coded, int which_tab); + /** + * Decode a huffman codebook descriptor from the bitstream + * and select specified huffman table. + * + * @param[in] ctx Decoder context + * @param[in] descCoded Flag signalling if table descriptor was coded + * @param[in] whichTab Codebook purpose (IVI_MB_HUFF or IVI_BLK_HUFF) + * @returns Zero on success, negative value otherwise + */ + int decodeHuffDesc(IVI45DecContext *ctx, int descCoded, int whichTab); }; /** @@ -237,7 +246,7 @@ struct IVIBandDesc { IVIBandDesc(); - int ivi_init_tiles(IVITile *ref_tile, int p, int b, int t_height, int t_width); + int initTiles(IVITile *refTile, int p, int b, int tHeight, int tWidth); }; struct IVIPicConfig { @@ -269,16 +278,27 @@ struct IVIPlaneDesc { IVIPlaneDesc(); - static int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool _isIndeo4); + static int initPlanes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool isIndeo4); - static int ff_ivi_init_tiles(IVIPlaneDesc *planes, int _tileWidth, int _tileHeight); + static int initTiles(IVIPlaneDesc *planes, int tileWidth, int tileHeight); /* * Free planes, bands and macroblocks buffers. * * @param[in] planes pointer to the array of the plane descriptors */ - static void ivi_free_buffers(IVIPlaneDesc *planes); + static void freeBuffers(IVIPlaneDesc *planes); + + /** + * Check if the given dimension of an image is valid, meaning that all + * bytes of the image can be addressed with a signed int. + * + * @param w the width of the picture + * @param h the height of the picture + * @param log_offset the offset to sum to the log level for logging with log_ctx + * @returns >= 0 if valid, a negative error code otherwise + */ + static int checkImageSize(unsigned int w, unsigned int h, int logOffset); }; struct AVFrame { @@ -327,22 +347,22 @@ struct AVFrame { /** * Destructor */ - ~AVFrame() { av_frame_free(); } + ~AVFrame() { freeFrame(); } /** * Sets the frame dimensions */ - int ff_set_dimensions(uint16 width, uint16 height); + int setDimensions(uint16 width, uint16 height); /** * Get a buffer for a frame */ - int ff_get_buffer(int flags); + int getBuffer(int flags); /** * Frees any data loaded for the frame */ - void av_frame_free(); + void freeFrame(); }; struct IVI45DecContext { @@ -424,43 +444,41 @@ private: /** * Haar wavelet recomposition filter for Indeo 4 * - * @param[in] plane pointer to the descriptor of the plane being processed - * @param[out] dst pointer to the destination buffer - * @param[in] dst_pitch _pitch of the destination buffer + * @param[in] plane Pointer to the descriptor of the plane being processed + * @param[out] dst pointer to the destination buffer + * @param[in] dstPitch Pitch of the destination buffer */ - void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8 *dst, - const int dst_pitch); + void recomposeHaar(const IVIPlaneDesc *plane, uint8 *dst, const int dstPitch); /** * 5/3 wavelet recomposition filter for Indeo5 * - * @param[in] plane pointer to the descriptor of the plane being processed - * @param[out] dst pointer to the destination buffer - * @param[in] dst_pitch _pitch of the destination buffer + * @param[in] plane Pointer to the descriptor of the plane being processed + * @param[out] dst Pointer to the destination buffer + * @param[in] dstPitch Pitch of the destination buffer */ - void ff_ivi_recompose53(const IVIPlaneDesc *plane, - uint8 *dst, const int dst_pitch); + void recompose53(const IVIPlaneDesc *plane, uint8 *dst, const int dstPitch); /* * Convert and output the current plane. * This conversion is done by adding back the bias value of 128 * (subtracted in the encoder) and clipping the result. * - * @param[in] plane pointer to the descriptor of the plane being processed - * @param[out] dst pointer to the buffer receiving converted pixels - * @param[in] dst_pitch _pitch for moving to the next y line + * @param[in] plane Pointer to the descriptor of the plane being processed + * @param[out] dst Pointer to the buffer receiving converted pixels + * @param[in] dstPitch Pitch for moving to the next y line */ - void ivi_output_plane(IVIPlaneDesc *plane, uint8 *dst, int dst_pitch); + void outputPlane(IVIPlaneDesc *plane, uint8 *dst, int dstPitch); /** * Handle empty tiles by performing data copying and motion * compensation respectively. * - * @param[in] band pointer to the band descriptor - * @param[in] tile pointer to the tile descriptor - * @param[in] mv_scale scaling factor for motion vectors + * @param[in] band Pointer to the band descriptor + * @param[in] tile Pointer to the tile descriptor + * @param[in] mvScale Scaling factor for motion vectors */ - int ivi_process_empty_tile(IVIBandDesc *band, IVITile *tile, int32 mv_scale); + int processEmptyTile(IVIBandDesc *band, IVITile *tile, int32 mvScale); /* * Decode size of the tile data. @@ -470,9 +488,9 @@ private: * where X1-X3 is size of the tile data * * @param[in,out] gb the GetBit context - * @return size of the tile data in bytes + * @returns Size of the tile data in bytes */ - int ivi_dec_tile_data_size(GetBits *gb); + int decodeTileDataSize(GetBits *gb); /* * Decode block data: @@ -480,21 +498,20 @@ private: * dequantize them, apply inverse transform and motion compensation * in order to reconstruct the picture. * - * @param[in,out] gb the GetBit context - * @param[in] band pointer to the band descriptor - * @param[in] tile pointer to the tile descriptor - * @return result code: 0 - OK, -1 = error (corrupted blocks data) + * @param[in,out] gb The GetBit context + * @param[in] band Pointer to the band descriptor + * @param[in] tile Pointer to the tile descriptor + * @returns Result code: 0 - OK, -1 = error (corrupted blocks data) */ - int ivi_decode_blocks(GetBits *gb, IVIBandDesc *band, IVITile *tile); + int decodeBlocks(GetBits *gb, IVIBandDesc *band, IVITile *tile); - int ivi_mc(IVIBandDesc *band, IviMCFunc mc, IviMCAvgFunc mc_avg, - int offs, int _mvX, int _mvY, int mv_x2, int mv_y2, - int mc_type, int mc_type2); + int iviMc(IVIBandDesc *band, IviMCFunc mc, IviMCAvgFunc mcAvg, + int offs, int mvX, int mvY, int mvX2, int mvY2, int mcType, int mcType2); int ivi_decode_coded_blocks(GetBits *gb, IVIBandDesc *band, - IviMCFunc mc, IviMCAvgFunc mc_avg, int _mvX, int _mvY, - int mv_x2, int mv_y2, int *prev_dc, int is_intra, - int mc_type, int mc_type2, uint32 quant, int offs); + IviMCFunc mc, IviMCAvgFunc mcAvg, int mvX, int mvY, + int mvX2, int mvY2, int *prevDc, int isIntra, + int mcType, int mcType2, uint32 quant, int offs); int ivi_dc_transform(IVIBandDesc *band, int *prevDc, int bufOffs, int blkSize); @@ -524,27 +541,27 @@ protected: /** * Rearrange decoding and reference buffers. */ - virtual void switch_buffers() = 0; + virtual void switchBuffers() = 0; - virtual bool is_nonnull_frame() const = 0; + virtual bool isNonNullFrame() const = 0; /** * Decode Indeo band header. * - * @param[in,out] band pointer to the band descriptor - * @return result code: 0 = OK, negative number = error + * @param[in,out] band Pointer to the band descriptor + * @returns Result code: 0 = OK, negative number = error */ - virtual int decode_band_hdr(IVIBandDesc *band) = 0; + virtual int decodeBandHeader(IVIBandDesc *band) = 0; /** * Decode information (block type, _cbp, quant delta, motion vector) * for all macroblocks in the current tile. * - * @param[in,out] band pointer to the band descriptor - * @param[in,out] tile pointer to the tile descriptor - * @return result code: 0 = OK, negative number = error + * @param[in,out] band Pointer to the band descriptor + * @param[in,out] tile Pointer to the tile descriptor + * @returns Result code: 0 = OK, negative number = error */ - virtual int decode_mb_info(IVIBandDesc *band, IVITile *tile)= 0; + virtual int decodeMbInfo(IVIBandDesc *band, IVITile *tile) = 0; /** * Decodes the Indeo frame from the bit reader already @@ -555,25 +572,12 @@ protected: /** * scale motion vector */ - int ivi_scale_mv(int mv, int mv_scale); + int scaleMV(int mv, int mvScale); public: IndeoDecoderBase(uint16 width, uint16 height); virtual ~IndeoDecoderBase(); }; -/*------------------------------------------------------------------------*/ - -/** - * Check if the given dimension of an image is valid, meaning that all - * bytes of the image can be addressed with a signed int. - * - * @param w the width of the picture - * @param h the height of the picture - * @param log_offset the offset to sum to the log level for logging with log_ctx - * @returns >= 0 if valid, a negative error code otherwise - */ -extern int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx); - } // End of namespace Indeo } // End of namespace Image diff --git a/image/codecs/indeo4.cpp b/image/codecs/indeo4.cpp index 12ab988bda..caefab2eab 100644 --- a/image/codecs/indeo4.cpp +++ b/image/codecs/indeo4.cpp @@ -175,7 +175,7 @@ int Indeo4Decoder::decodePictureHeader() { // check if picture layout was changed and reallocate buffers if (_picConf.ivi_pic_config_cmp(_ctx._picConf)) { - if (IVIPlaneDesc::ff_ivi_init_planes(_ctx._planes, &_picConf, 1)) { + if (IVIPlaneDesc::initPlanes(_ctx._planes, &_picConf, 1)) { warning("Couldn't reallocate color planes!"); _ctx._picConf._lumaBands = 0; return -2; @@ -191,7 +191,7 @@ int Indeo4Decoder::decodePictureHeader() { } } - if (IVIPlaneDesc::ff_ivi_init_tiles(_ctx._planes, _ctx._picConf._tileWidth, + if (IVIPlaneDesc::initTiles(_ctx._planes, _ctx._picConf._tileWidth, _ctx._picConf._tileHeight)) { warning("Couldn't reallocate internal structures!"); return -2; @@ -205,8 +205,8 @@ int Indeo4Decoder::decodePictureHeader() { _ctx._gb->skipBits(8); // decode macroblock and block huffman codebooks - if (_ctx._mbVlc.ff_ivi_dec_huff_desc(&_ctx, _ctx._gb->getBits1(), IVI_MB_HUFF) || - _ctx._blkVlc.ff_ivi_dec_huff_desc(&_ctx, _ctx._gb->getBits1(), IVI_BLK_HUFF)) + if (_ctx._mbVlc.decodeHuffDesc(&_ctx, _ctx._gb->getBits1(), IVI_MB_HUFF) || + _ctx._blkVlc.decodeHuffDesc(&_ctx, _ctx._gb->getBits1(), IVI_BLK_HUFF)) return -1; _ctx._rvmapSel = _ctx._gb->getBits1() ? _ctx._gb->getBits(3) : 8; @@ -235,7 +235,7 @@ int Indeo4Decoder::decodePictureHeader() { return 0; } -void Indeo4Decoder::switch_buffers() { +void Indeo4Decoder::switchBuffers() { int is_prev_ref = 0, is_ref = 0; switch (_ctx._prevFrameType) { @@ -265,18 +265,18 @@ void Indeo4Decoder::switch_buffers() { } } -bool Indeo4Decoder::is_nonnull_frame() const { +bool Indeo4Decoder::isNonNullFrame() const { return _ctx._frameType < IVI4_FRAMETYPE_NULL_FIRST; } -int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { - int plane, _bandNum, indx, transform_id, scan_indx; +int Indeo4Decoder::decodeBandHeader(IVIBandDesc *band) { + int plane, bandNum, indx, transformId, scanIndx; int i; - int _quantMat; + int quantMat; plane = _ctx._gb->getBits(2); - _bandNum = _ctx._gb->getBits(4); - if (band->_plane != plane || band->_bandNum != _bandNum) { + bandNum = _ctx._gb->getBits(4); + if (band->_plane != plane || band->_bandNum != bandNum) { warning("Invalid band header sequence!"); return -1; } @@ -316,30 +316,30 @@ int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { band->_globQuant = _ctx._gb->getBits(5); if (!_ctx._gb->getBits1() || _ctx._frameType == IVI4_FRAMETYPE_INTRA) { - transform_id = _ctx._gb->getBits(5); - if ((uint)transform_id >= FF_ARRAY_ELEMS(_transforms) || - !_transforms[transform_id]._invTrans) { - warning("Transform %d", transform_id); + transformId = _ctx._gb->getBits(5); + if ((uint)transformId >= FF_ARRAY_ELEMS(_transforms) || + !_transforms[transformId]._invTrans) { + warning("Transform %d", transformId); return -3; } - if ((transform_id >= 7 && transform_id <= 9) || - transform_id == 17) { + if ((transformId >= 7 && transformId <= 9) || + transformId == 17) { warning("DCT transform"); return -3; } - if (transform_id < 10 && band->_blkSize < 8) { + if (transformId < 10 && band->_blkSize < 8) { warning("wrong transform size!"); return -1; } - if ((transform_id >= 0 && transform_id <= 2) || transform_id == 10) + if ((transformId >= 0 && transformId <= 2) || transformId == 10) _ctx._usesHaar = true; - band->_invTransform = _transforms[transform_id]._invTrans; - band->_dcTransform = _transforms[transform_id]._dcTrans; - band->_is2dTrans = _transforms[transform_id]._is2dTrans; + band->_invTransform = _transforms[transformId]._invTrans; + band->_dcTransform = _transforms[transformId]._dcTrans; + band->_is2dTrans = _transforms[transformId]._is2dTrans; - if (transform_id < 10) + if (transformId < 10) band->_transformSize = 8; else band->_transformSize = 4; @@ -349,12 +349,12 @@ int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { return -1; } - scan_indx = _ctx._gb->getBits(4); - if (scan_indx == 15) { + scanIndx = _ctx._gb->getBits(4); + if (scanIndx == 15) { warning("Custom scan pattern encountered!"); return -1; } - if (scan_indx > 4 && scan_indx < 10) { + if (scanIndx > 4 && scanIndx < 10) { if (band->_blkSize != 4) { warning("mismatching scan table!"); return -1; @@ -364,19 +364,19 @@ int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { return -1; } - band->_scan = _scan_index_to_tab[scan_indx]; + band->_scan = _scan_index_to_tab[scanIndx]; band->_scanSize = band->_blkSize; - _quantMat = _ctx._gb->getBits(5); - if (_quantMat == 31) { + quantMat = _ctx._gb->getBits(5); + if (quantMat == 31) { warning("Custom quant matrix encountered!"); return -1; } - if ((uint)_quantMat >= FF_ARRAY_ELEMS(_quant_index_to_tab)) { - warning("Quantization matrix %d", _quantMat); + if ((uint)quantMat >= FF_ARRAY_ELEMS(_quant_index_to_tab)) { + warning("Quantization matrix %d", quantMat); return -1; } - band->_quantMat = _quantMat; + band->_quantMat = quantMat; } else { if (old_blk_size != band->_blkSize) { warning("The band block size does not match the configuration inherited"); @@ -401,7 +401,7 @@ int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { if (!_ctx._gb->getBits1()) band->_blkVlc._tab = _ctx._blkVlc._tab; else - if (band->_blkVlc.ff_ivi_dec_huff_desc(&_ctx, 1, IVI_BLK_HUFF)) + if (band->_blkVlc.decodeHuffDesc(&_ctx, 1, IVI_BLK_HUFF)) return -1; // select appropriate rvmap table for this band @@ -445,35 +445,35 @@ int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { return 0; } -int Indeo4Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { - int x, y, _mvX, _mvY, mv_delta, offs, mb_offset, blks_per_mb, - mv_scale, mb_type_bits, s; - IVIMbInfo *mb, *ref_mb; - int row_offset = band->_mbSize * band->_pitch; +int Indeo4Decoder::decodeMbInfo(IVIBandDesc *band, IVITile *tile) { + int x, y, mvX, mvY, mvDelta, offs, mbOffset, blksPerMb, + mvScale, mbTypeBits, s; + IVIMbInfo *mb, *ref_mb; + int row_offset = band->_mbSize * band->_pitch; mb = tile->_mbs; ref_mb = tile->_refMbs; offs = tile->_yPos * band->_pitch + tile->_xPos; - blks_per_mb = band->_mbSize != band->_blkSize ? 4 : 1; - mb_type_bits = _ctx._frameType == IVI4_FRAMETYPE_BIDIR ? 2 : 1; + blksPerMb = band->_mbSize != band->_blkSize ? 4 : 1; + mbTypeBits = _ctx._frameType == IVI4_FRAMETYPE_BIDIR ? 2 : 1; /* scale factor for motion vectors */ - mv_scale = (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3); - _mvX = _mvY = 0; + mvScale = (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3); + mvX = mvY = 0; if (((tile->_width + band->_mbSize - 1) / band->_mbSize) * ((tile->_height + band->_mbSize - 1) / band->_mbSize) != tile->_numMBs) { - warning("_numMBs mismatch %d %d %d %d", tile->_width, tile->_height, band->_mbSize, tile->_numMBs); + warning("numMBs mismatch %d %d %d %d", tile->_width, tile->_height, band->_mbSize, tile->_numMBs); return -1; } for (y = tile->_yPos; y < tile->_yPos + tile->_height; y += band->_mbSize) { - mb_offset = offs; + mbOffset = offs; for (x = tile->_xPos; x < tile->_xPos + tile->_width; x += band->_mbSize) { mb->_xPos = x; mb->_yPos = y; - mb->_bufOffs = mb_offset; + mb->_bufOffs = mbOffset; mb->_bMvX = mb->_bMvY = 0; if (_ctx._gb->getBits1()) { @@ -494,9 +494,9 @@ int Indeo4Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { mb->_mvX = mb->_mvY = 0; // no motion vector coded if (band->_inheritMv && ref_mb) { // motion vector inheritance - if (mv_scale) { - mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); - mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); + if (mvScale) { + mb->_mvX = scaleMV(ref_mb->_mvX, mvScale); + mb->_mvY = scaleMV(ref_mb->_mvY, mvScale); } else { mb->_mvX = ref_mb->_mvX; mb->_mvY = ref_mb->_mvY; @@ -514,10 +514,10 @@ int Indeo4Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { _ctx._frameType == IVI4_FRAMETYPE_INTRA1) { mb->_type = 0; // mb_type is always INTRA for intra-frames } else { - mb->_type = _ctx._gb->getBits(mb_type_bits); + mb->_type = _ctx._gb->getBits(mbTypeBits); } - mb->_cbp = _ctx._gb->getBits(blks_per_mb); + mb->_cbp = _ctx._gb->getBits(blksPerMb); mb->_qDelta = 0; if (band->_inheritQDelta) { @@ -535,9 +535,9 @@ int Indeo4Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { if (band->_inheritMv) { if (ref_mb) { // motion vector inheritance - if (mv_scale) { - mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); - mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); + if (mvScale) { + mb->_mvX = scaleMV(ref_mb->_mvX, mvScale); + mb->_mvY = scaleMV(ref_mb->_mvY, mvScale); } else { mb->_mvX = ref_mb->_mvX; mb->_mvY = ref_mb->_mvY; @@ -545,25 +545,25 @@ int Indeo4Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { } } else { // decode motion vector deltas - mv_delta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, + mvDelta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - _mvY += IVI_TOSIGNED(mv_delta); - mv_delta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, + mvY += IVI_TOSIGNED(mvDelta); + mvDelta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - _mvX += IVI_TOSIGNED(mv_delta); - mb->_mvX = _mvX; - mb->_mvY = _mvY; + mvX += IVI_TOSIGNED(mvDelta); + mb->_mvX = mvX; + mb->_mvY = mvY; if (mb->_type == 3) { - mv_delta = _ctx._gb->getVLC2( + mvDelta = _ctx._gb->getVLC2( _ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - _mvY += IVI_TOSIGNED(mv_delta); - mv_delta = _ctx._gb->getVLC2( + mvY += IVI_TOSIGNED(mvDelta); + mvDelta = _ctx._gb->getVLC2( _ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - _mvX += IVI_TOSIGNED(mv_delta); - mb->_bMvX = -_mvX; - mb->_bMvY = -_mvY; + mvX += IVI_TOSIGNED(mvDelta); + mb->_bMvX = -mvX; + mb->_bMvY = -mvY; } } if (mb->_type == 2) { @@ -587,7 +587,7 @@ int Indeo4Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { mb++; if (ref_mb) ref_mb++; - mb_offset += band->_mbSize; + mbOffset += band->_mbSize; } offs += row_offset; @@ -597,8 +597,8 @@ int Indeo4Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { return 0; } -int Indeo4Decoder::scaleTileSize(int def_size, int size_factor) { - return size_factor == 15 ? def_size : (size_factor + 1) << 5; +int Indeo4Decoder::scaleTileSize(int defSize, int sizeFactor) { + return sizeFactor == 15 ? defSize : (sizeFactor + 1) << 5; } int Indeo4Decoder::decodePlaneSubdivision() { @@ -607,11 +607,13 @@ int Indeo4Decoder::decodePlaneSubdivision() { switch (_ctx._gb->getBits(2)) { case 3: return 1; + case 2: for (i = 0; i < 4; i++) if (_ctx._gb->getBits(2) != 3) return 0; return 4; + default: return 0; } diff --git a/image/codecs/indeo4.h b/image/codecs/indeo4.h index 86e6020c43..26bddaa4b3 100644 --- a/image/codecs/indeo4.h +++ b/image/codecs/indeo4.h @@ -73,9 +73,9 @@ protected: /** * Rearrange decoding and reference buffers. */ - virtual void switch_buffers(); + virtual void switchBuffers(); - virtual bool is_nonnull_frame() const; + virtual bool isNonNullFrame() const; /** * Decode Indeo 4 band header. @@ -83,7 +83,7 @@ protected: * @param[in,out] band pointer to the band descriptor * @return result code: 0 = OK, negative number = error */ - virtual int decode_band_hdr(IVIBandDesc *band); + virtual int decodeBandHeader(IVIBandDesc *band); /** * Decode information (block type, cbp, quant delta, motion vector) @@ -93,9 +93,9 @@ protected: * @param[in,out] tile pointer to the tile descriptor * @return result code: 0 = OK, negative number = error */ - virtual int decode_mb_info(IVIBandDesc *band, IVITile *tile); + virtual int decodeMbInfo(IVIBandDesc *band, IVITile *tile); private: - int scaleTileSize(int def_size, int size_factor); + int scaleTileSize(int defSize, int sizeFactor); /** * Decode subdivision of a plane. @@ -104,8 +104,8 @@ private: * - 4 wavelet bands per plane, size factor 1:4, code pattern: 2,3,3,3,3 * Anything else is either unsupported or corrupt. * - * @param[in,out] gb the GetBit context - * @return number of wavelet bands or 0 on error + * @param[in,out] gb The GetBit context + * @returns Number of wavelet bands or 0 on error */ int decodePlaneSubdivision(); diff --git a/image/codecs/indeo5.cpp b/image/codecs/indeo5.cpp index 5434e26cfa..6eacbb80f7 100644 --- a/image/codecs/indeo5.cpp +++ b/image/codecs/indeo5.cpp @@ -103,8 +103,8 @@ const Graphics::Surface *Indeo5Decoder::decodeFrame(Common::SeekableReadStream & } int Indeo5Decoder::decodePictureHeader() { - int pic_size_indx, i, p; - IVIPicConfig pic_conf; + int picSizeIndx, i, p; + IVIPicConfig picConf; int ret; @@ -149,7 +149,7 @@ int Indeo5Decoder::decodePictureHeader() { skip_hdr_extension(); // XXX: untested // decode macroblock huffman codebook - ret = _ctx._mbVlc.ff_ivi_dec_huff_desc(&_ctx, _ctx._frameFlags & 0x40, + ret = _ctx._mbVlc.decodeHuffDesc(&_ctx, _ctx._frameFlags & 0x40, IVI_MB_HUFF); if (ret < 0) return ret; @@ -161,7 +161,7 @@ int Indeo5Decoder::decodePictureHeader() { return 0; } -void Indeo5Decoder::switch_buffers() { +void Indeo5Decoder::switchBuffers() { switch (_ctx._prevFrameType) { case FRAMETYPE_INTRA: case FRAMETYPE_INTER: @@ -169,6 +169,7 @@ void Indeo5Decoder::switch_buffers() { _ctx._dstBuf = _ctx._bufSwitch; _ctx._refBuf = _ctx._bufSwitch ^ 1; break; + case FRAMETYPE_INTER_SCAL: if (!_ctx._interScal) { _ctx._ref2Buf = 2; @@ -177,6 +178,7 @@ void Indeo5Decoder::switch_buffers() { FFSWAP(int, _ctx._dstBuf, _ctx._ref2Buf); _ctx._refBuf = _ctx._ref2Buf; break; + case FRAMETYPE_INTER_NOREF: break; } @@ -190,6 +192,7 @@ void Indeo5Decoder::switch_buffers() { _ctx._dstBuf = _ctx._bufSwitch; _ctx._refBuf = _ctx._bufSwitch ^ 1; break; + case FRAMETYPE_INTER_SCAL: case FRAMETYPE_INTER_NOREF: case FRAMETYPE_NULL: @@ -197,32 +200,32 @@ void Indeo5Decoder::switch_buffers() { } } -bool Indeo5Decoder::is_nonnull_frame() const { +bool Indeo5Decoder::isNonNullFrame() const { return _ctx._frameType != FRAMETYPE_NULL; } -int Indeo5Decoder::decode_band_hdr(IVIBandDesc *band) { +int Indeo5Decoder::decodeBandHeader(IVIBandDesc *band) { int i, ret; - uint8 band_flags; + uint8 bandFlags; - band_flags = _ctx._gb->getBits(8); + bandFlags = _ctx._gb->getBits(8); - if (band_flags & 1) { + if (bandFlags & 1) { band->_isEmpty = true; return 0; } band->_dataSize = (_ctx._frameFlags & 0x80) ? _ctx._gb->getBitsLong(24) : 0; - band->_inheritMv = (band_flags & 2) != 0; - band->_inheritQDelta = (band_flags & 8) != 0; - band->_qdeltaPresent = (band_flags & 4) != 0; + band->_inheritMv = (bandFlags & 2) != 0; + band->_inheritQDelta = (bandFlags & 8) != 0; + band->_qdeltaPresent = (bandFlags & 4) != 0; if (!band->_qdeltaPresent) band->_inheritQDelta = 1; // decode rvmap probability corrections if any band->_numCorr = 0; // there are no corrections - if (band_flags & 0x10) { + if (bandFlags & 0x10) { band->_numCorr = _ctx._gb->getBits(8); // get number of correction pairs if (band->_numCorr > 61) { warning("Too many corrections: %d", band->_numCorr); @@ -235,10 +238,10 @@ int Indeo5Decoder::decode_band_hdr(IVIBandDesc *band) { } // select appropriate rvmap table for this band - band->_rvmapSel = (band_flags & 0x40) ? _ctx._gb->getBits(3) : 8; + band->_rvmapSel = (bandFlags & 0x40) ? _ctx._gb->getBits(3) : 8; // decode block huffman codebook - ret = band->_blkVlc.ff_ivi_dec_huff_desc(&_ctx, band_flags & 0x80, IVI_BLK_HUFF); + ret = band->_blkVlc.decodeHuffDesc(&_ctx, bandFlags & 0x80, IVI_BLK_HUFF); if (ret < 0) return ret; @@ -249,7 +252,7 @@ int Indeo5Decoder::decode_band_hdr(IVIBandDesc *band) { band->_globQuant = _ctx._gb->getBits(5); // skip unknown extension if any - if (band_flags & 0x20) { // XXX: untested + if (bandFlags & 0x20) { // XXX: untested _ctx._gb->alignGetBits(); skip_hdr_extension(); } @@ -259,17 +262,17 @@ int Indeo5Decoder::decode_band_hdr(IVIBandDesc *band) { return 0; } -int Indeo5Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { - int x, y, _mvX, _mvY, mv_delta, offs, mb_offset, - mv_scale, blks_per_mb, s; - IVIMbInfo *mb, *ref_mb; - int row_offset = band->_mbSize * band->_pitch; +int Indeo5Decoder::decodeMbInfo(IVIBandDesc *band, IVITile *tile) { + int x, y, mvX, mvY, mvDelta, offs, mbOffset, + mvScale, blksPerMb, s; + IVIMbInfo *mb, *refMb; + int rowOffset = band->_mbSize * band->_pitch; mb = tile->_mbs; - ref_mb = tile->_refMbs; + refMb = tile->_refMbs; offs = tile->_yPos * band->_pitch + tile->_xPos; - if (!ref_mb && + if (!refMb && ((band->_qdeltaPresent && band->_inheritQDelta) || band->_inheritMv)) return -1; @@ -280,16 +283,16 @@ int Indeo5Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { } // scale factor for motion vectors - mv_scale = (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3); - _mvX = _mvY = 0; + mvScale = (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3); + mvX = mvY = 0; for (y = tile->_yPos; y < (tile->_yPos + tile->_height); y += band->_mbSize) { - mb_offset = offs; + mbOffset = offs; for (x = tile->_xPos; x < (tile->_xPos + tile->_width); x += band->_mbSize) { mb->_xPos = x; mb->_yPos = y; - mb->_bufOffs = mb_offset; + mb->_bufOffs = mbOffset; if (_ctx._gb->getBits1()) { if (_ctx._frameType == FRAMETYPE_INTRA) { @@ -306,32 +309,32 @@ int Indeo5Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { } mb->_mvX = mb->_mvY = 0; // no motion vector coded - if (band->_inheritMv && ref_mb) { + if (band->_inheritMv && refMb) { // motion vector inheritance - if (mv_scale) { - mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); - mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); + if (mvScale) { + mb->_mvX = scaleMV(refMb->_mvX, mvScale); + mb->_mvY = scaleMV(refMb->_mvY, mvScale); } else { - mb->_mvX = ref_mb->_mvX; - mb->_mvY = ref_mb->_mvY; + mb->_mvX = refMb->_mvX; + mb->_mvY = refMb->_mvY; } } } else { - if (band->_inheritMv && ref_mb) { - mb->_type = ref_mb->_type; // copy mb_type from corresponding reference mb + if (band->_inheritMv && refMb) { + mb->_type = refMb->_type; // copy mb_type from corresponding reference mb } else if (_ctx._frameType == FRAMETYPE_INTRA) { mb->_type = 0; // mb_type is always INTRA for intra-frames } else { mb->_type = _ctx._gb->getBits1(); } - blks_per_mb = band->_mbSize != band->_blkSize ? 4 : 1; - mb->_cbp = _ctx._gb->getBits(blks_per_mb); + blksPerMb = band->_mbSize != band->_blkSize ? 4 : 1; + mb->_cbp = _ctx._gb->getBits(blksPerMb); mb->_qDelta = 0; if (band->_qdeltaPresent) { if (band->_inheritQDelta) { - if (ref_mb) mb->_qDelta = ref_mb->_qDelta; + if (refMb) mb->_qDelta = refMb->_qDelta; } else if (mb->_cbp || (!band->_plane && !band->_bandNum && (_ctx._frameFlags & 8))) { mb->_qDelta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); @@ -342,23 +345,23 @@ int Indeo5Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { if (!mb->_type) { mb->_mvX = mb->_mvY = 0; // there is no motion vector in intra-macroblocks } else { - if (band->_inheritMv && ref_mb) { + if (band->_inheritMv && refMb) { // motion vector inheritance - if (mv_scale) { - mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); - mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); + if (mvScale) { + mb->_mvX = scaleMV(refMb->_mvX, mvScale); + mb->_mvY = scaleMV(refMb->_mvY, mvScale); } else { - mb->_mvX = ref_mb->_mvX; - mb->_mvY = ref_mb->_mvY; + mb->_mvX = refMb->_mvX; + mb->_mvY = refMb->_mvY; } } else { // decode motion vector deltas - mv_delta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - _mvY += IVI_TOSIGNED(mv_delta); - mv_delta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - _mvX += IVI_TOSIGNED(mv_delta); - mb->_mvX = _mvX; - mb->_mvY = _mvY; + mvDelta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); + mvY += IVI_TOSIGNED(mvDelta); + mvDelta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); + mvX += IVI_TOSIGNED(mvDelta); + mb->_mvX = mvX; + mb->_mvY = mvY; } } } @@ -373,12 +376,12 @@ int Indeo5Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { } mb++; - if (ref_mb) - ref_mb++; - mb_offset += band->_mbSize; + if (refMb) + refMb++; + mbOffset += band->_mbSize; } - offs += row_offset; + offs += rowOffset; } _ctx._gb->alignGetBits(); @@ -387,11 +390,11 @@ int Indeo5Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { } int Indeo5Decoder::decode_gop_header() { - int result, i, p, tile_size, pic_size_indx, mbSize, blkSize, isScalable; + int result, i, p, tile_size, picSizeIndx, mbSize, blkSize, isScalable; int quantMat; - bool blk_size_changed = false; + bool blkSizeChanged = false; IVIBandDesc *band, *band1, *band2; - IVIPicConfig pic_conf; + IVIPicConfig picConf; _ctx._gopFlags = _ctx._gb->getBits(8); @@ -408,22 +411,22 @@ int Indeo5Decoder::decode_gop_header() { // decode number of wavelet bands // num_levels * 3 + 1 - pic_conf._lumaBands = _ctx._gb->getBits(2) * 3 + 1; - pic_conf._chromaBands = _ctx._gb->getBits1() * 3 + 1; - isScalable = pic_conf._lumaBands != 1 || pic_conf._chromaBands != 1; - if (isScalable && (pic_conf._lumaBands != 4 || pic_conf._chromaBands != 1)) { + picConf._lumaBands = _ctx._gb->getBits(2) * 3 + 1; + picConf._chromaBands = _ctx._gb->getBits1() * 3 + 1; + isScalable = picConf._lumaBands != 1 || picConf._chromaBands != 1; + if (isScalable && (picConf._lumaBands != 4 || picConf._chromaBands != 1)) { warning("Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d", - pic_conf._lumaBands, pic_conf._chromaBands); + picConf._lumaBands, picConf._chromaBands); return -1; } - pic_size_indx = _ctx._gb->getBits(4); - if (pic_size_indx == IVI5_PIC_SIZE_ESC) { - pic_conf._picHeight = _ctx._gb->getBits(13); - pic_conf._picWidth = _ctx._gb->getBits(13); + picSizeIndx = _ctx._gb->getBits(4); + if (picSizeIndx == IVI5_PIC_SIZE_ESC) { + picConf._picHeight = _ctx._gb->getBits(13); + picConf._picWidth = _ctx._gb->getBits(13); } else { - pic_conf._picHeight = _ivi5_common_pic_sizes[pic_size_indx * 2 + 1] << 2; - pic_conf._picWidth = _ivi5_common_pic_sizes[pic_size_indx * 2] << 2; + picConf._picHeight = _ivi5_common_pic_sizes[picSizeIndx * 2 + 1] << 2; + picConf._picWidth = _ivi5_common_pic_sizes[picSizeIndx * 2] << 2; } if (_ctx._gopFlags & 2) { @@ -431,30 +434,30 @@ int Indeo5Decoder::decode_gop_header() { return -2; } - pic_conf._chromaHeight = (pic_conf._picHeight + 3) >> 2; - pic_conf._chromaWidth = (pic_conf._picWidth + 3) >> 2; + picConf._chromaHeight = (picConf._picHeight + 3) >> 2; + picConf._chromaWidth = (picConf._picWidth + 3) >> 2; if (!tile_size) { - pic_conf._tileHeight = pic_conf._picHeight; - pic_conf._tileWidth = pic_conf._picWidth; + picConf._tileHeight = picConf._picHeight; + picConf._tileWidth = picConf._picWidth; } else { - pic_conf._tileHeight = pic_conf._tileWidth = tile_size; + picConf._tileHeight = picConf._tileWidth = tile_size; } // check if picture layout was changed and reallocate buffers - if (pic_conf.ivi_pic_config_cmp(_ctx._picConf) || _ctx._gopInvalid) { - result = IVIPlaneDesc::ff_ivi_init_planes(_ctx._planes, &pic_conf, 0); + if (picConf.ivi_pic_config_cmp(_ctx._picConf) || _ctx._gopInvalid) { + result = IVIPlaneDesc::initPlanes(_ctx._planes, &picConf, 0); if (result < 0) { warning("Couldn't reallocate color planes!"); return result; } - _ctx._picConf = pic_conf; + _ctx._picConf = picConf; _ctx._isScalable = isScalable; - blk_size_changed = 1; // force reallocation of the internal structures + blkSizeChanged = 1; // force reallocation of the internal structures } for (p = 0; p <= 1; p++) { - for (i = 0; i < (!p ? pic_conf._lumaBands : pic_conf._chromaBands); i++) { + for (i = 0; i < (!p ? picConf._lumaBands : picConf._chromaBands); i++) { band = &_ctx._planes[p]._bands[i]; band->_isHalfpel = _ctx._gb->getBits1(); @@ -468,8 +471,8 @@ int Indeo5Decoder::decode_gop_header() { return -2; } - blk_size_changed = mbSize != band->_mbSize || blkSize != band->_blkSize; - if (blk_size_changed) { + blkSizeChanged = mbSize != band->_mbSize || blkSize != band->_blkSize; + if (blkSizeChanged) { band->_mbSize = mbSize; band->_blkSize = blkSize; } @@ -527,7 +530,7 @@ int Indeo5Decoder::decode_gop_header() { // select dequant matrix according to plane and band number if (!p) { - quantMat = (pic_conf._lumaBands > 1) ? i + 1 : 0; + quantMat = (picConf._lumaBands > 1) ? i + 1 : 0; } else { quantMat = 5; } @@ -556,7 +559,7 @@ int Indeo5Decoder::decode_gop_header() { } // copy chroma parameters into the 2nd chroma plane - for (i = 0; i < pic_conf._chromaBands; i++) { + for (i = 0; i < picConf._chromaBands; i++) { band1 = &_ctx._planes[1]._bands[i]; band2 = &_ctx._planes[2]._bands[i]; @@ -577,9 +580,9 @@ int Indeo5Decoder::decode_gop_header() { } // reallocate internal structures if needed - if (blk_size_changed) { - result = IVIPlaneDesc::ff_ivi_init_tiles(_ctx._planes, pic_conf._tileWidth, - pic_conf._tileHeight); + if (blkSizeChanged) { + result = IVIPlaneDesc::initTiles(_ctx._planes, picConf._tileWidth, + picConf._tileHeight); if (result < 0) { warning("Couldn't reallocate internal structures!"); return result; diff --git a/image/codecs/indeo5.h b/image/codecs/indeo5.h index 102c610be8..9832967d5d 100644 --- a/image/codecs/indeo5.h +++ b/image/codecs/indeo5.h @@ -73,9 +73,9 @@ protected: /** * Rearrange decoding and reference buffers. */ - virtual void switch_buffers(); + virtual void switchBuffers(); - virtual bool is_nonnull_frame() const; + virtual bool isNonNullFrame() const; /** * Decode Indeo 4 band header. @@ -83,7 +83,7 @@ protected: * @param[in,out] band pointer to the band descriptor * @return result code: 0 = OK, negative number = error */ - virtual int decode_band_hdr(IVIBandDesc *band); + virtual int decodeBandHeader(IVIBandDesc *band); /** * Decode information (block type, cbp, quant delta, motion vector) @@ -93,7 +93,7 @@ protected: * @param[in,out] tile pointer to the tile descriptor * @return result code: 0 = OK, negative number = error */ - virtual int decode_mb_info(IVIBandDesc *band, IVITile *tile); + virtual int decodeMbInfo(IVIBandDesc *band, IVITile *tile); private: /** * Decode Indeo5 GOP (Group of pictures) header. -- cgit v1.2.3