diff options
Diffstat (limited to 'image')
| -rw-r--r-- | image/codecs/indeo/indeo.cpp | 934 | ||||
| -rw-r--r-- | image/codecs/indeo/indeo.h | 315 | ||||
| -rw-r--r-- | image/codecs/indeo4.cpp | 465 | ||||
| -rw-r--r-- | image/codecs/indeo4.h | 6 | ||||
| -rw-r--r-- | image/codecs/indeo5.cpp | 482 |
5 files changed, 1102 insertions, 1100 deletions
diff --git a/image/codecs/indeo/indeo.cpp b/image/codecs/indeo/indeo.cpp index 1968638436..632e39ea7b 100644 --- a/image/codecs/indeo/indeo.cpp +++ b/image/codecs/indeo/indeo.cpp @@ -79,7 +79,7 @@ static const IVIHuffDesc ivi_blk_huff_desc[8] = { /*------------------------------------------------------------------------*/ /** - * calculate number of tiles in a stride + * calculate number of _tiles in a stride */ #define IVI_NUM_TILES(stride, tile_size) (((stride) + (tile_size) - 1) / (tile_size)) @@ -92,16 +92,16 @@ int IVIHuffDesc::ivi_create_huff_from_desc(VLC *vlc, int flag) const { pos = 0; // current position = 0 - for (i = 0; i < num_rows; i++) { - codes_per_row = 1 << xbits[i]; - not_last_row = (i != num_rows - 1); - prefix = ((1 << i) - 1) << (xbits[i] + not_last_row); + 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); for (j = 0; j < codes_per_row; 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] + not_last_row; if (bits[pos] > IVI_VLC_BITS) return -1; // invalid descriptor @@ -121,18 +121,18 @@ int IVIHuffDesc::ivi_create_huff_from_desc(VLC *vlc, int flag) const { /*------------------------------------------------------------------------*/ bool IVIHuffDesc::ivi_huff_desc_cmp(const IVIHuffDesc *desc2) const { - return num_rows != desc2->num_rows || - memcmp(xbits, desc2->xbits, num_rows); + return _numRows != desc2->_numRows || + memcmp(_xBits, desc2->_xBits, _numRows); } void IVIHuffDesc::ivi_huff_desc_copy(const IVIHuffDesc *src) { - num_rows = src->num_rows; - memcpy(xbits, src->xbits, src->num_rows); + _numRows = src->_numRows; + memcpy(_xBits, src->_xBits, src->_numRows); } /*------------------------------------------------------------------------*/ -IVIHuffTab::IVIHuffTab() : tab(nullptr) { +IVIHuffTab::IVIHuffTab() : _tab(nullptr) { } int IVIHuffTab::ff_ivi_dec_huff_desc(IVI45DecContext *ctx, int desc_coded, int which_tab) { @@ -141,42 +141,42 @@ int IVIHuffTab::ff_ivi_dec_huff_desc(IVI45DecContext *ctx, int desc_coded, int w if (!desc_coded) { // select default table - tab = (which_tab) ? &ctx->ivi_blk_vlc_tabs[7] - : &ctx->ivi_mb_vlc_tabs[7]; + _tab = (which_tab) ? &ctx->_iviBlkVlcTabs[7] + : &ctx->_iviMbVlcTabs[7]; return 0; } - tab_sel = ctx->gb->getBits(3); - if (tab_sel == 7) { + _tabSel = ctx->_gb->getBits(3); + if (_tabSel == 7) { // custom huffman table (explicitly encoded) - new_huff.num_rows = ctx->gb->getBits(4); - if (!new_huff.num_rows) { + new_huff._numRows = ctx->_gb->getBits(4); + if (!new_huff._numRows) { warning("Empty custom Huffman table!"); return -1; } - for (i = 0; i < new_huff.num_rows; i++) - new_huff.xbits[i] = ctx->gb->getBits(4); + for (i = 0; i < new_huff._numRows; i++) + new_huff._xBits[i] = ctx->_gb->getBits(4); // Have we got the same custom table? Rebuild if not. - if (new_huff.ivi_huff_desc_cmp(&cust_desc) || !cust_tab._table) { - cust_desc.ivi_huff_desc_copy(&new_huff); + if (new_huff.ivi_huff_desc_cmp(&_custDesc) || !_custTab._table) { + _custDesc.ivi_huff_desc_copy(&new_huff); - if (cust_tab._table) - cust_tab.ff_free_vlc(); - result = cust_desc.ivi_create_huff_from_desc(&cust_tab, 0); + if (_custTab._table) + _custTab.ff_free_vlc(); + result = _custDesc.ivi_create_huff_from_desc(&_custTab, 0); if (result) { // reset faulty description - cust_desc.num_rows = 0; + _custDesc._numRows = 0; warning("Error while initializing custom vlc table!"); return result; } } - tab = &cust_tab; + _tab = &_custTab; } else { // select one of predefined tables - tab = (which_tab) ? &ctx->ivi_blk_vlc_tabs[tab_sel] - : &ctx->ivi_mb_vlc_tabs[tab_sel]; + _tab = (which_tab) ? &ctx->_iviBlkVlcTabs[_tabSel] + : &ctx->_iviMbVlcTabs[_tabSel]; } return 0; @@ -184,60 +184,62 @@ int IVIHuffTab::ff_ivi_dec_huff_desc(IVI45DecContext *ctx, int desc_coded, int w /*------------------------------------------------------------------------*/ -IVIMbInfo::IVIMbInfo() : xpos(0), ypos(0), buf_offs(0), type(0), cbp(0), - q_delta(0), mv_x(0), mv_y(0), b_mv_x(0), b_mv_y(0) { +IVIMbInfo::IVIMbInfo() : _xPos(0), _yPos(0), _bufOffs(0), _type(0), _cbp(0), + _qDelta(0), _mvX(0), _mvY(0), _bMvX(0), _bMvY(0) { } /*------------------------------------------------------------------------*/ -IVITile::IVITile() : xpos(0), ypos(0), width(0), height(0), mb_size(0), - is_empty(0), data_size(0), num_MBs(0), mbs(nullptr), ref_mbs(nullptr) { +IVITile::IVITile() : _xPos(0), _yPos(0), _width(0), _height(0), _mbSize(0), + _isEmpty(false), _dataSize(0), _numMBs(0), _mbs(nullptr), _refMbs(nullptr) { } /*------------------------------------------------------------------------*/ -IVIBandDesc::IVIBandDesc() : plane(0), band_num(0), width(0), height(0), - aheight(0), data_ptr(nullptr), data_size(0), buf(nullptr), - ref_buf(nullptr), b_ref_buf(nullptr), pitch(0), is_empty(0), - mb_size(0), blk_size(0), is_halfpel(0), inherit_mv(0), bufsize(0), - inherit_qdelta(0), qdelta_present(0), quant_mat(0), glob_quant(0), - scan(nullptr), scan_size(0), num_corr(0), rvmap_sel(0), rv_map(nullptr), - num_tiles(0), tiles(nullptr), inv_transform(nullptr), transform_size(0), - dc_transform(nullptr), is_2d_trans(0), checksum(0), checksum_present(0), - intra_base(nullptr), inter_base(nullptr), intra_scale(nullptr), - inter_scale(nullptr) { - Common::fill(&bufs[0], &bufs[4], (int16 *)nullptr); - Common::fill(&corr[0], &corr[61 * 2], 0); +IVIBandDesc::IVIBandDesc() : _plane(0), _bandNum(0), _width(0), _height(0), + _aHeight(0), _dataPtr(nullptr), _dataSize(0), _buf(nullptr), + _refBuf(nullptr), _bRefBuf(nullptr), _pitch(0), _isEmpty(false), + _mbSize(0), _blkSize(0), _isHalfpel(false), _inheritMv(false), _bufSize(0), + _inheritQDelta(false), _qdeltaPresent(false), _quantMat(0), _globQuant(0), + _scan(nullptr), _scanSize(0), _numCorr(0), _rvmapSel(0), _rvMap(nullptr), + _numTiles(0), _tiles(nullptr), _invTransform(nullptr), _transformSize(0), + _dcTransform(nullptr), _is2dTrans(0), _checksum(0), _checksumPresent(false), + _intraBase(nullptr), _interBase(nullptr), _intraScale(nullptr), + _interScale(nullptr) { + Common::fill(&_bufs[0], &_bufs[4], (int16 *)nullptr); + 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 x, y; - IVITile *tile = tiles; - - for (y = 0; y < height; y += t_height) { - for (x = 0; x < width; x += t_width) { - tile->xpos = x; - tile->ypos = y; - tile->mb_size = mb_size; - tile->width = MIN(width - x, t_width); - tile->height = MIN(height - y, t_height); - tile->is_empty = tile->data_size = 0; + IVITile *tile = _tiles; + + for (y = 0; y < _height; y += t_height) { + for (x = 0; x < _width; x += t_width) { + tile->_xPos = x; + tile->_yPos = y; + tile->_mbSize = _mbSize; + tile->_width = MIN(_width - x, t_width); + tile->_height = MIN(_height - y, t_height); + tile->_dataSize = 0; + tile->_isEmpty = false; + // calculate number of macroblocks - tile->num_MBs = IVI_MBs_PER_TILE(tile->width, tile->height, - mb_size); + tile->_numMBs = IVI_MBs_PER_TILE(tile->_width, tile->_height, + _mbSize); - av_freep(&tile->mbs); - tile->mbs = (IVIMbInfo *)av_mallocz_array(tile->num_MBs, sizeof(IVIMbInfo)); - if (!tile->mbs) + av_freep(&tile->_mbs); + tile->_mbs = (IVIMbInfo *)av_mallocz_array(tile->_numMBs, sizeof(IVIMbInfo)); + if (!tile->_mbs) return -2; - tile->ref_mbs = 0; + tile->_refMbs = 0; if (p || b) { - if (tile->num_MBs != ref_tile->num_MBs) { + if (tile->_numMBs != ref_tile->_numMBs) { warning("ref_tile mismatch"); return -1; } - tile->ref_mbs = ref_tile->mbs; + tile->_refMbs = ref_tile->_mbs; ref_tile++; } tile++; @@ -249,23 +251,23 @@ int IVIBandDesc::ivi_init_tiles(IVITile *ref_tile, int p, int b, int t_height, i /*------------------------------------------------------------------------*/ -IVIPicConfig::IVIPicConfig() : pic_width(0), pic_height(0), chroma_width(0), - chroma_height(0), tile_width(0), tile_height(0), luma_bands(0), chroma_bands(0) { +IVIPicConfig::IVIPicConfig() : _picWidth(0), _picHeight(0), _chromaWidth(0), + _chromaHeight(0), _tileWidth(0), _tileHeight(0), _lumaBands(0), _chromaBands(0) { } bool IVIPicConfig::ivi_pic_config_cmp(const IVIPicConfig &cfg2) { - return pic_width != cfg2.pic_width || pic_height != cfg2.pic_height || - chroma_width != cfg2.chroma_width || chroma_height != cfg2.chroma_height || - tile_width != cfg2.tile_width || tile_height != cfg2.tile_height || - luma_bands != cfg2.luma_bands || chroma_bands != cfg2.chroma_bands; + return _picWidth != cfg2._picWidth || _picHeight != cfg2._picHeight || + _chromaWidth != cfg2._chromaWidth || _chromaHeight != cfg2._chromaHeight || + _tileWidth != cfg2._tileWidth || _tileHeight != cfg2._tileHeight || + _lumaBands != cfg2._lumaBands || _chromaBands != cfg2._chromaBands; } /*------------------------------------------------------------------------*/ -IVIPlaneDesc::IVIPlaneDesc() : width(0), height(0), num_bands(0), bands(nullptr) { +IVIPlaneDesc::IVIPlaneDesc() : _width(0), _height(0), _numBands(0), _bands(nullptr) { } -int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool is_indeo4) { +int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool _isIndeo4) { int p, b; uint32 b_width, b_height, align_fac, width_aligned, height_aligned, buf_size; @@ -273,32 +275,32 @@ int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *c ivi_free_buffers(planes); - if (av_image_check_size(cfg->pic_width, cfg->pic_height, 0, NULL) < 0 || - cfg->luma_bands < 1 || cfg->chroma_bands < 1) + if (av_image_check_size(cfg->_picWidth, cfg->_picHeight, 0, NULL) < 0 || + cfg->_lumaBands < 1 || cfg->_chromaBands < 1) return -1; - // fill in the descriptor of the luminance plane - planes[0].width = cfg->pic_width; - planes[0].height = cfg->pic_height; - planes[0].num_bands = cfg->luma_bands; + // fill in the descriptor of the luminance _plane + planes[0]._width = cfg->_picWidth; + planes[0]._height = cfg->_picHeight; + planes[0]._numBands = cfg->_lumaBands; // fill in the descriptors of the chrominance planes - planes[1].width = planes[2].width = (cfg->pic_width + 3) >> 2; - planes[1].height = planes[2].height = (cfg->pic_height + 3) >> 2; - planes[1].num_bands = planes[2].num_bands = cfg->chroma_bands; + planes[1]._width = planes[2]._width = (cfg->_picWidth + 3) >> 2; + planes[1]._height = planes[2]._height = (cfg->_picHeight + 3) >> 2; + planes[1]._numBands = planes[2]._numBands = cfg->_chromaBands; for (p = 0; p < 3; p++) { - planes[p].bands = (IVIBandDesc *)av_mallocz_array(planes[p].num_bands, sizeof(IVIBandDesc)); - if (!planes[p].bands) + planes[p]._bands = (IVIBandDesc *)av_mallocz_array(planes[p]._numBands, sizeof(IVIBandDesc)); + if (!planes[p]._bands) return -2; // select band dimensions: if there is only one band then it // has the full size, if there are several bands each of them // has only half size - b_width = planes[p].num_bands == 1 ? planes[p].width - : (planes[p].width + 1) >> 1; - b_height = planes[p].num_bands == 1 ? planes[p].height - : (planes[p].height + 1) >> 1; + b_width = planes[p]._numBands == 1 ? planes[p]._width + : (planes[p]._width + 1) >> 1; + b_height = planes[p]._numBands == 1 ? planes[p]._height + : (planes[p]._height + 1) >> 1; // luma band buffers will be aligned on 16x16 (max macroblock size) // chroma band buffers will be aligned on 8x8 (max macroblock size) @@ -307,33 +309,33 @@ int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *c height_aligned = FFALIGN(b_height, align_fac); buf_size = width_aligned * height_aligned * sizeof(int16); - for (b = 0; b < planes[p].num_bands; b++) { - band = &planes[p].bands[b]; // select appropriate plane/band - band->plane = p; - band->band_num = b; - band->width = b_width; - 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; - if (!band->bufs[0] || !band->bufs[1]) + for (b = 0; b < planes[p]._numBands; b++) { + band = &planes[p]._bands[b]; // select appropriate _plane/band + band->_plane = p; + band->_bandNum = b; + band->_width = b_width; + 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; + if (!band->_bufs[0] || !band->_bufs[1]) return -2; // allocate the 3rd band buffer for scalability mode - if (cfg->luma_bands > 1) { - band->bufs[2] = (int16 *)av_mallocz(buf_size); - if (!band->bufs[2]) + if (cfg->_lumaBands > 1) { + band->_bufs[2] = (int16 *)av_mallocz(buf_size); + if (!band->_bufs[2]) return -2; } - if (is_indeo4) { - band->bufs[3] = (int16 *)av_mallocz(buf_size); - if (!band->bufs[3]) + if (_isIndeo4) { + band->_bufs[3] = (int16 *)av_mallocz(buf_size); + if (!band->_bufs[3]) return -2; } // reset custom vlc - planes[p].bands[0].blk_vlc.cust_desc.num_rows = 0; + planes[p]._bands[0]._blkVlc._custDesc._numRows = 0; } } @@ -341,35 +343,35 @@ int IVIPlaneDesc::ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *c } int IVIPlaneDesc::ff_ivi_init_tiles(IVIPlaneDesc *planes, - int tile_width, int tile_height) { + int _tileWidth, int _tileHeight) { int p, b, x_tiles, y_tiles, t_width, t_height, ret; IVIBandDesc *band; for (p = 0; p < 3; p++) { - t_width = !p ? tile_width : (tile_width + 3) >> 2; - t_height = !p ? tile_height : (tile_height + 3) >> 2; + t_width = !p ? _tileWidth : (_tileWidth + 3) >> 2; + t_height = !p ? _tileHeight : (_tileHeight + 3) >> 2; - if (!p && planes[0].num_bands == 4) { + if (!p && planes[0]._numBands == 4) { t_width >>= 1; t_height >>= 1; } if (t_width <= 0 || t_height <= 0) return -3; - for (b = 0; b < planes[p].num_bands; 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->num_tiles = x_tiles * y_tiles; + 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; - av_freep(&band->tiles); - band->tiles = (IVITile *)av_mallocz_array(band->num_tiles, sizeof(IVITile)); - if (!band->tiles) + av_freep(&band->_tiles); + band->_tiles = (IVITile *)av_mallocz_array(band->_numTiles, sizeof(IVITile)); + if (!band->_tiles) return -2; // use the first luma band as reference for motion vectors // and quant - ret = band->ivi_init_tiles(planes[0].bands[0].tiles, + ret = band->ivi_init_tiles(planes[0]._bands[0]._tiles, p, b, t_height, t_width); if (ret < 0) return ret; @@ -383,21 +385,21 @@ void IVIPlaneDesc::ivi_free_buffers(IVIPlaneDesc *planes) { int p, b, t; for (p = 0; p < 3; p++) { - if (planes[p].bands) - for (b = 0; b < planes[p].num_bands; b++) { - av_freep(&planes[p].bands[b].bufs[0]); - av_freep(&planes[p].bands[b].bufs[1]); - av_freep(&planes[p].bands[b].bufs[2]); - av_freep(&planes[p].bands[b].bufs[3]); - - if (planes[p].bands[b].blk_vlc.cust_tab._table) - planes[p].bands[b].blk_vlc.cust_tab.ff_free_vlc(); - for (t = 0; t < planes[p].bands[b].num_tiles; t++) - av_freep(&planes[p].bands[b].tiles[t].mbs); - av_freep(&planes[p].bands[b].tiles); + if (planes[p]._bands) + for (b = 0; b < planes[p]._numBands; b++) { + av_freep(&planes[p]._bands[b]._bufs[0]); + av_freep(&planes[p]._bands[b]._bufs[1]); + av_freep(&planes[p]._bands[b]._bufs[2]); + av_freep(&planes[p]._bands[b]._bufs[3]); + + if (planes[p]._bands[b]._blkVlc._custTab._table) + planes[p]._bands[b]._blkVlc._custTab.ff_free_vlc(); + for (t = 0; t < planes[p]._bands[b]._numTiles; t++) + av_freep(&planes[p]._bands[b]._tiles[t]._mbs); + av_freep(&planes[p]._bands[b]._tiles); } - av_freep(&planes[p].bands); - planes[p].num_bands = 0; + av_freep(&planes[p]._bands); + planes[p]._numBands = 0; } } @@ -439,48 +441,48 @@ void AVFrame::av_frame_free() { /*------------------------------------------------------------------------*/ -IVI45DecContext::IVI45DecContext() : gb(nullptr), frame_num(0), frame_type(0), - prev_frame_type(0), data_size(0), is_scalable(0), frame_data(0), - inter_scal(0), frame_size(0), pic_hdr_size(0), frame_flags(0), - checksum(0), buf_switch(0), dst_buf(0), ref_buf(0), ref2_buf(0), - b_ref_buf(0), rvmap_sel(0), in_imf(0), in_q(0), pic_glob_quant(0), - unknown1(0), gop_hdr_size(0), gop_flags(0), lock_word(0), has_b_frames(0), - has_transp(0), uses_tiling(0), uses_haar(0), uses_fullpel(0), gop_invalid(0), - is_indeo4(0), p_frame(nullptr), got_p_frame(0) { - Common::fill(&buf_invalid[0], &buf_invalid[4], 0); - Common::copy(&_ff_ivi_rvmap_tabs[0], &_ff_ivi_rvmap_tabs[9], &rvmap_tabs[0]); +IVI45DecContext::IVI45DecContext() : _gb(nullptr), _frameNum(0), _frameType(0), + _prevFrameType(0), _dataSize(0), _isScalable(0), _frameData(0), + _interScal(0), _frameSize(0), _picHdrSize(0), _frameFlags(0), + _checksum(0), _bufSwitch(0), _dstBuf(0), _refBuf(0), _ref2Buf(0), + _bRefBuf(0), _rvmapSel(0), _inImf(false), _inQ(false), _picGlobQuant(0), + _unknown1(0), _gopHdrSize(0), _gopFlags(0), _lockWord(0), _hasBFrames(false), + _hasTransp(false), _usesTiling(false), _usesHaar(false), _usesFullpel(false), + _gopInvalid(false), _isIndeo4(false), _pFrame(nullptr), _gotPFrame(false) { + Common::fill(&_bufInvalid[0], &_bufInvalid[4], 0); + Common::copy(&_ff_ivi_rvmap_tabs[0], &_ff_ivi_rvmap_tabs[9], &_rvmapTabs[0]); for (int idx = 0; idx < (8192 * 16); ++idx) - table_data[idx][0] = table_data[idx][1] = 0; + _tableData[idx][0] = _tableData[idx][1] = 0; for (int i = 0; i < 8; i++) { - ivi_mb_vlc_tabs[i]._table = table_data + i * 2 * 8192; - ivi_mb_vlc_tabs[i]._table_allocated = 8192; - ivi_mb_huff_desc[i].ivi_create_huff_from_desc(&ivi_mb_vlc_tabs[i], 1); - ivi_blk_vlc_tabs[i]._table = table_data + (i * 2 + 1) * 8192; - ivi_blk_vlc_tabs[i]._table_allocated = 8192; - ivi_blk_huff_desc[i].ivi_create_huff_from_desc(&ivi_blk_vlc_tabs[i], 1); + _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); + _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); } } /*------------------------------------------------------------------------*/ -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); - _ctx.b_ref_buf = 3; // buffer 2 is used for scalability mode + _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); - if (_ctx.mb_vlc.cust_tab._table) - _ctx.mb_vlc.cust_tab.ff_free_vlc(); + IVIPlaneDesc::ivi_free_buffers(_ctx._planes); + if (_ctx._mbVlc._custTab._table) + _ctx._mbVlc._custTab.ff_free_vlc(); - delete _ctx.p_frame; + delete _ctx._pFrame; } int IndeoDecoderBase::decodeIndeoFrame() { @@ -492,20 +494,20 @@ int IndeoDecoderBase::decodeIndeoFrame() { if (decodePictureHeader() < 0) return -1; - if (_ctx.gop_invalid) + if (_ctx._gopInvalid) return -1; - if (_ctx.frame_type == IVI4_FRAMETYPE_NULL_LAST) { + if (_ctx._frameType == IVI4_FRAMETYPE_NULL_LAST) { // Returning the previous frame, so exit wth success return 0; } - if (_ctx.gop_flags & IVI5_IS_PROTECTED) { + if (_ctx._gopFlags & IVI5_IS_PROTECTED) { warning("Password-protected clip"); return -1; } - if (!_ctx.planes[0].bands) { + if (!_ctx._planes[0]._bands) { warning("Color planes not initialized yet"); return -1; } @@ -515,27 +517,27 @@ int IndeoDecoderBase::decodeIndeoFrame() { //{ START_TIMER; if (is_nonnull_frame()) { - _ctx.buf_invalid[_ctx.dst_buf] = 1; + _ctx._bufInvalid[_ctx._dstBuf] = 1; for (p = 0; p < 3; p++) { - for (b = 0; b < _ctx.planes[p].num_bands; b++) { - result = decode_band(&_ctx.planes[p].bands[b]); + for (b = 0; b < _ctx._planes[p]._numBands; b++) { + result = decode_band(&_ctx._planes[p]._bands[b]); if (result < 0) { - warning("Error while decoding band: %d, plane: %d", b, p); + warning("Error while decoding band: %d, _plane: %d", b, p); return result; } } } - _ctx.buf_invalid[_ctx.dst_buf] = 0; + _ctx._bufInvalid[_ctx._dstBuf] = 0; } else { - if (_ctx.is_scalable) + if (_ctx._isScalable) return -1; for (p = 0; p < 3; p++) { - if (!_ctx.planes[p].bands[0].buf) + if (!_ctx._planes[p]._bands[0]._buf) return -1; } } - if (_ctx.buf_invalid[_ctx.dst_buf]) + if (_ctx._bufInvalid[_ctx._dstBuf]) return -1; //STOP_TIMER("decode_planes"); } @@ -543,42 +545,42 @@ int IndeoDecoderBase::decodeIndeoFrame() { if (!is_nonnull_frame()) 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); + 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); if (result < 0) return result; if ((result = frame->ff_get_buffer(0)) < 0) return result; - if (_ctx.is_scalable) { - if (_ctx.is_indeo4) - ff_ivi_recompose_haar(&_ctx.planes[0], frame->_data[0], frame->_linesize[0]); + if (_ctx._isScalable) { + if (_ctx._isIndeo4) + ff_ivi_recompose_haar(&_ctx._planes[0], frame->_data[0], frame->_linesize[0]); else - ff_ivi_recompose53(&_ctx.planes[0], frame->_data[0], frame->_linesize[0]); + ff_ivi_recompose53(&_ctx._planes[0], frame->_data[0], frame->_linesize[0]); } else { - ivi_output_plane(&_ctx.planes[0], frame->_data[0], frame->_linesize[0]); + ivi_output_plane(&_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]); + ivi_output_plane(&_ctx._planes[2], frame->_data[1], frame->_linesize[1]); + ivi_output_plane(&_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 // to be the only way to handle the B-frames mode. // That's exactly the same Intel decoders do. - if (_ctx.is_indeo4 && _ctx.frame_type == IVI4_FRAMETYPE_INTRA) { + if (_ctx._isIndeo4 && _ctx._frameType == IVI4_FRAMETYPE_INTRA) { int left; // skip version string - while (_ctx.gb->getBits(8)) { - if (_ctx.gb->getBitsLeft() < 8) + while (_ctx._gb->getBits(8)) { + if (_ctx._gb->getBitsLeft() < 8) return -1; } - left = _ctx.gb->getBitsCount() & 0x18; - _ctx.gb->skipBitsLong(64 - left); - if (_ctx.gb->getBitsLeft() > 18 && - _ctx.gb->showBitsLong(21) == 0xBFFF8) { // syncheader + inter type + left = _ctx._gb->getBitsCount() & 0x18; + _ctx._gb->skipBitsLong(64 - left); + if (_ctx._gb->getBitsLeft() > 18 && + _ctx._gb->showBitsLong(21) == 0xBFFF8) { // syncheader + inter _type error("Indeo decoder: Mode not currently implemented in ScummVM"); } } @@ -599,19 +601,19 @@ int IndeoDecoderBase::decode_band(IVIBandDesc *band) { int result, i, t, idx1, idx2, pos; IVITile * tile; - band->buf = band->bufs[_ctx.dst_buf]; - if (!band->buf) { + band->_buf = band->_bufs[_ctx._dstBuf]; + if (!band->_buf) { warning("Band buffer points to no data!"); return -1; } - if (_ctx.is_indeo4 && _ctx.frame_type == IVI4_FRAMETYPE_BIDIR) { - band->ref_buf = band->bufs[_ctx.b_ref_buf]; - band->b_ref_buf = band->bufs[_ctx.ref_buf]; + if (_ctx._isIndeo4 && _ctx._frameType == IVI4_FRAMETYPE_BIDIR) { + band->_refBuf = band->_bufs[_ctx._bRefBuf]; + band->_bRefBuf = band->_bufs[_ctx._refBuf]; } else { - band->ref_buf = band->bufs[_ctx.ref_buf]; - band->b_ref_buf = 0; + band->_refBuf = band->_bufs[_ctx._refBuf]; + band->_bRefBuf = 0; } - band->data_ptr = _ctx.frame_data + (_ctx.gb->getBitsCount() >> 3); + band->_dataPtr = _ctx._frameData + (_ctx._gb->getBitsCount() >> 3); result = decode_band_hdr(band); if (result) { @@ -620,45 +622,45 @@ int IndeoDecoderBase::decode_band(IVIBandDesc *band) { return result; } - if (band->is_empty) { + if (band->_isEmpty) { warning("Empty band encountered!"); return -1; } - band->rv_map = &_ctx.rvmap_tabs[band->rvmap_sel]; + band->_rvMap = &_ctx._rvmapTabs[band->_rvmapSel]; // apply corrections to the selected rvmap table if present - for (i = 0; i < band->num_corr; i++) { - idx1 = band->corr[i * 2]; - idx2 = band->corr[i * 2 + 1]; - FFSWAP(uint8, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]); - FFSWAP(int16, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]); - if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym) - band->rv_map->eob_sym ^= idx1 ^ idx2; - if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym) - band->rv_map->esc_sym ^= idx1 ^ idx2; + for (i = 0; i < band->_numCorr; i++) { + idx1 = band->_corr[i * 2]; + idx2 = band->_corr[i * 2 + 1]; + FFSWAP(uint8, band->_rvMap->_runtab[idx1], band->_rvMap->_runtab[idx2]); + FFSWAP(int16, band->_rvMap->_valtab[idx1], band->_rvMap->_valtab[idx2]); + if (idx1 == band->_rvMap->_eobSym || idx2 == band->_rvMap->_eobSym) + band->_rvMap->_eobSym ^= idx1 ^ idx2; + if (idx1 == band->_rvMap->_escSym || idx2 == band->_rvMap->_escSym) + band->_rvMap->_escSym ^= idx1 ^ idx2; } - pos = _ctx.gb->getBitsCount(); + pos = _ctx._gb->getBitsCount(); - for (t = 0; t < band->num_tiles; t++) { - tile = &band->tiles[t]; + for (t = 0; t < band->_numTiles; t++) { + tile = &band->_tiles[t]; - if (tile->mb_size != band->mb_size) { + if (tile->_mbSize != band->_mbSize) { warning("MB sizes mismatch: %d vs. %d", - band->mb_size, tile->mb_size); + band->_mbSize, tile->_mbSize); return -1; } - tile->is_empty = _ctx.gb->getBits1(); - if (tile->is_empty) { + tile->_isEmpty = _ctx._gb->getBits1(); + if (tile->_isEmpty) { result = ivi_process_empty_tile(band, tile, - (_ctx.planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3)); + (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3)); if (result < 0) break; warning("Empty tile encountered!"); } else { - tile->data_size = ivi_dec_tile_data_size(_ctx.gb); - if (!tile->data_size) { + tile->_dataSize = ivi_dec_tile_data_size(_ctx._gb); + if (!tile->_dataSize) { warning("Tile data size is zero!"); result = -1; break; @@ -668,62 +670,62 @@ int IndeoDecoderBase::decode_band(IVIBandDesc *band) { if (result < 0) break; - result = ivi_decode_blocks(_ctx.gb, band, tile); + result = ivi_decode_blocks(_ctx._gb, band, tile); if (result < 0) { warning("Corrupted tile data encountered!"); break; } - if ((((int)_ctx.gb->getBitsCount() - pos) >> 3) != tile->data_size) { - warning("Tile data_size mismatch!"); + if ((((int)_ctx._gb->getBitsCount() - pos) >> 3) != tile->_dataSize) { + warning("Tile _dataSize mismatch!"); result = -1; break; } - pos += tile->data_size << 3; // skip to next tile + pos += tile->_dataSize << 3; // skip to next tile } } // restore the selected rvmap table by applying its corrections in // reverse order - for (i = band->num_corr - 1; i >= 0; i--) { - idx1 = band->corr[i * 2]; - idx2 = band->corr[i * 2 + 1]; - FFSWAP(uint8, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]); - FFSWAP(int16, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]); - if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym) - band->rv_map->eob_sym ^= idx1 ^ idx2; - if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym) - band->rv_map->esc_sym ^= idx1 ^ idx2; + for (i = band->_numCorr - 1; i >= 0; i--) { + idx1 = band->_corr[i * 2]; + idx2 = band->_corr[i * 2 + 1]; + FFSWAP(uint8, band->_rvMap->_runtab[idx1], band->_rvMap->_runtab[idx2]); + FFSWAP(int16, band->_rvMap->_valtab[idx1], band->_rvMap->_valtab[idx2]); + if (idx1 == band->_rvMap->_eobSym || idx2 == band->_rvMap->_eobSym) + band->_rvMap->_eobSym ^= idx1 ^ idx2; + if (idx1 == band->_rvMap->_escSym || idx2 == band->_rvMap->_escSym) + band->_rvMap->_escSym ^= idx1 ^ idx2; } - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); return result; } -void IndeoDecoderBase::ff_ivi_recompose_haar(const IVIPlaneDesc *plane, +void IndeoDecoderBase::ff_ivi_recompose_haar(const IVIPlaneDesc *_plane, uint8 *dst, const int dst_pitch) { int x, y, indx, b0, b1, b2, b3, p0, p1, p2, p3; const short * b0_ptr, *b1_ptr, *b2_ptr, *b3_ptr; - int32 pitch; + int32 _pitch; - // all bands should have the same pitch - pitch = plane->bands[0].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; + b0_ptr = _plane->_bands[0]._buf; + b1_ptr = _plane->_bands[1]._buf; + b2_ptr = _plane->_bands[2]._buf; + b3_ptr = _plane->_bands[3]._buf; - for (y = 0; y < plane->height; y += 2) { - for (x = 0, indx = 0; x < plane->width; x += 2, indx++) { + 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 = (num_bands > 0) ? b0_ptr[indx] : 0; - b1 = b1_ptr[indx]; //should be: b1 = (num_bands > 1) ? b1_ptr[indx] : 0; - b2 = b2_ptr[indx]; //should be: b2 = (num_bands > 2) ? b2_ptr[indx] : 0; - b3 = b3_ptr[indx]; //should be: b3 = (num_bands > 3) ? b3_ptr[indx] : 0; + 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; // haar wavelet recomposition p0 = (b0 + b1 + b2 + b3 + 2) >> 2; @@ -740,70 +742,70 @@ void IndeoDecoderBase::ff_ivi_recompose_haar(const IVIPlaneDesc *plane, dst += dst_pitch << 1; - b0_ptr += pitch; - b1_ptr += pitch; - b2_ptr += pitch; - b3_ptr += pitch; + b0_ptr += _pitch; + b1_ptr += _pitch; + b2_ptr += _pitch; + b3_ptr += _pitch; }// for y } -void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *plane, +void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *_plane, uint8 *dst, const int dst_pitch) { 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; + int32 _pitch, back_pitch; const short * b0_ptr, *b1_ptr, *b2_ptr, *b3_ptr; - const int num_bands = 4; + const int _numBands = 4; - // all bands should have the same pitch - pitch = plane->bands[0].pitch; + // all bands should have the same _pitch + _pitch = _plane->_bands[0]._pitch; // pixels at the position "y-1" will be set to pixels at the "y" for the 1st iteration 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; + b0_ptr = _plane->_bands[0]._buf; + b1_ptr = _plane->_bands[1]._buf; + b2_ptr = _plane->_bands[2]._buf; + b3_ptr = _plane->_bands[3]._buf; - for (y = 0; y < plane->height; y += 2) { + for (y = 0; y < _plane->_height; y += 2) { - if (y + 2 >= plane->height) - pitch = 0; + if (y + 2 >= _plane->_height) + _pitch = 0; // load storage variables with values - if (num_bands > 0) { + if (_numBands > 0) { b0_1 = b0_ptr[0]; - b0_2 = b0_ptr[pitch]; + b0_2 = b0_ptr[_pitch]; } - if (num_bands > 1) { + 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_3 = b1_1 - b1_2 * 6 + b1_ptr[_pitch]; } - if (num_bands > 2) { + 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_5 = b2_ptr[_pitch]; // b2[x ,y+1] b2_6 = b2_5; // b2[x+1,y+1] = b2[x,y+1] } - if (num_bands > 3) { + 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_8 = b3_2 - b3_5 * 6 + b3_ptr[_pitch]; b3_9 = b3_8; } - for (x = 0, indx = 0; x < plane->width; x += 2, indx++) { - if (x + 2 >= plane->width) { + for (x = 0, indx = 0; x < _plane->_width; x += 2, indx++) { + if (x + 2 >= _plane->_width) { b0_ptr--; b1_ptr--; b2_ptr--; @@ -826,11 +828,11 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *plane, p0 = p1 = p2 = p3 = 0; // process the LL-band by applying LPF both vertically and horizontally - if (num_bands > 0) { + if (_numBands > 0) { tmp0 = b0_1; tmp2 = b0_2; b0_1 = b0_ptr[indx + 1]; - b0_2 = b0_ptr[pitch + indx + 1]; + b0_2 = b0_ptr[_pitch + indx + 1]; tmp1 = tmp0 + b0_1; p0 = tmp0 << 4; @@ -840,14 +842,14 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *plane, } // process the HL-band by applying HPF vertically and LPF horizontally - if (num_bands > 1) { + if (_numBands > 1) { tmp0 = b1_2; tmp1 = b1_1; b1_2 = b1_ptr[indx + 1]; b1_1 = b1_ptr[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 + b1_ptr[_pitch + indx + 1]; p0 += (tmp0 + tmp1) << 3; p1 += (tmp0 + tmp1 + b1_1 + b1_2) << 2; @@ -856,9 +858,9 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *plane, } // process the LH-band by applying LPF vertically and HPF horizontally - if (num_bands > 2) { + if (_numBands > 2) { b2_3 = b2_ptr[indx + 1]; - b2_6 = b2_ptr[pitch + indx + 1]; + b2_6 = b2_ptr[_pitch + indx + 1]; tmp0 = b2_1 + b2_2; tmp1 = b2_1 - b2_2 * 6 + b2_3; @@ -870,7 +872,7 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *plane, } // process the HH-band by applying HPF both vertically and horizontally - if (num_bands > 3) { + 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] @@ -878,7 +880,7 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *plane, 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 + b3_ptr[_pitch + indx + 1]; p0 += (tmp0 + tmp1) << 2; p1 += (tmp0 - tmp1 * 6 + tmp2) << 1; @@ -895,95 +897,95 @@ void IndeoDecoderBase::ff_ivi_recompose53(const IVIPlaneDesc *plane, dst += dst_pitch << 1; - back_pitch = -pitch; + back_pitch = -_pitch; - b0_ptr += pitch + 1; - b1_ptr += pitch + 1; - b2_ptr += pitch + 1; - b3_ptr += pitch + 1; + b0_ptr += _pitch + 1; + b1_ptr += _pitch + 1; + b2_ptr += _pitch + 1; + b3_ptr += _pitch + 1; } } -void IndeoDecoderBase::ivi_output_plane(IVIPlaneDesc *plane, uint8 *dst, int dst_pitch) { +void IndeoDecoderBase::ivi_output_plane(IVIPlaneDesc *_plane, uint8 *dst, int dst_pitch) { int x, y; - const int16 * src = plane->bands[0].buf; - uint32 pitch = plane->bands[0].pitch; + const int16 * src = _plane->_bands[0]._buf; + uint32 _pitch = _plane->_bands[0]._pitch; if (!src) return; - for (y = 0; y < plane->height; y++) { - for (x = 0; x < plane->width; x++) + for (y = 0; y < _plane->_height; y++) { + for (x = 0; x < _plane->_width; x++) dst[x] = av_clip_uint8(src[x] + 128); - src += pitch; + src += _pitch; dst += dst_pitch; } } int IndeoDecoderBase::ivi_process_empty_tile(IVIBandDesc *band, IVITile *tile, int32 mv_scale) { - int x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type; + int x, y, need_mc, mbn, blk, num_blocks, _mvX, _mvY, mc_type; int offs, mb_offset, row_offset, ret; IVIMbInfo *mb, *ref_mb; - const int16 *src; - int16 *dst; - ivi_mc_func mc_no_delta_func; + const int16 * src; + int16 * dst; + IviMCFunc mc_no_delta_func; - if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size)) { + 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()", - tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size)); + 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->ref_mbs; - row_offset = band->mb_size * band->pitch; + 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 - for (y = tile->ypos; y < (tile->ypos + tile->height); y += band->mb_size) { + for (y = tile->_yPos; y < (tile->_yPos + tile->_height); y += band->_mbSize) { mb_offset = offs; - for (x = tile->xpos; x < (tile->xpos + tile->width); x += band->mb_size) { - mb->xpos = x; - mb->ypos = y; - mb->buf_offs = mb_offset; + for (x = tile->_xPos; x < (tile->_xPos + tile->_width); x += band->_mbSize) { + mb->_xPos = x; + mb->_yPos = y; + mb->_bufOffs = mb_offset; - mb->type = 1; // set the macroblocks type = INTER - mb->cbp = 0; // all blocks are empty + mb->_type = 1; // set the macroblocks _type = INTER + mb->_cbp = 0; // all blocks are empty - if (!band->qdelta_present && !band->plane && !band->band_num) { - mb->q_delta = band->glob_quant; - mb->mv_x = 0; - mb->mv_y = 0; + if (!band->_qdeltaPresent && !band->_plane && !band->_bandNum) { + mb->_qDelta = band->_globQuant; + mb->_mvX = 0; + mb->_mvY = 0; } - if (band->inherit_qdelta && ref_mb) - mb->q_delta = ref_mb->q_delta; + if (band->_inheritQDelta && ref_mb) + mb->_qDelta = ref_mb->_qDelta; - if (band->inherit_mv && ref_mb) { + if (band->_inheritMv && ref_mb) { // motion vector inheritance if (mv_scale) { - mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); - mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale); + mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); + mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); } else { - mb->mv_x = ref_mb->mv_x; - mb->mv_y = ref_mb->mv_y; + mb->_mvX = ref_mb->_mvX; + mb->_mvY = ref_mb->_mvY; } - need_mc |= mb->mv_x || mb->mv_y; // tracking non-zero motion vectors + need_mc |= mb->_mvX || mb->_mvY; // tracking non-zero motion vectors { int dmv_x, dmv_y, cx, cy; - dmv_x = mb->mv_x >> band->is_halfpel; - dmv_y = mb->mv_y >> band->is_halfpel; - cx = mb->mv_x & band->is_halfpel; - cy = mb->mv_y & band->is_halfpel; + dmv_x = mb->_mvX >> band->_isHalfpel; + dmv_y = mb->_mvY >> band->_isHalfpel; + cx = mb->_mvX & band->_isHalfpel; + cy = mb->_mvY & band->_isHalfpel; - if (mb->xpos + dmv_x < 0 - || mb->xpos + dmv_x + band->mb_size + cx > band->pitch - || mb->ypos + dmv_y < 0 - || mb->ypos + dmv_y + band->mb_size + cy > band->aheight) { + if (mb->_xPos + dmv_x < 0 + || mb->_xPos + dmv_x + band->_mbSize + cx > band->_pitch + || mb->_yPos + dmv_y < 0 + || mb->_yPos + dmv_y + band->_mbSize + cy > band->_aHeight) { warning("MV out of bounds"); return -1; } @@ -993,82 +995,82 @@ int IndeoDecoderBase::ivi_process_empty_tile(IVIBandDesc *band, mb++; if (ref_mb) ref_mb++; - mb_offset += band->mb_size; + mb_offset += band->_mbSize; } // for x offs += row_offset; } // for y - if (band->inherit_mv && need_mc) { // apply motion compensation if there is at least one non-zero motion vector - num_blocks = (band->mb_size != band->blk_size) ? 4 : 1; // number of blocks per mb - mc_no_delta_func = (band->blk_size == 8) ? IndeoDSP::ff_ivi_mc_8x8_no_delta + 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 : IndeoDSP::ff_ivi_mc_4x4_no_delta; - for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) { - mv_x = mb->mv_x; - mv_y = mb->mv_y; - if (!band->is_halfpel) { + for (mbn = 0, mb = tile->_mbs; mbn < tile->_numMBs; mb++, mbn++) { + _mvX = mb->_mvX; + _mvY = mb->_mvY; + if (!band->_isHalfpel) { mc_type = 0; // we have only fullpel vectors } else { - mc_type = ((mv_y & 1) << 1) | (mv_x & 1); - mv_x >>= 1; - mv_y >>= 1; // convert halfpel vectors into fullpel ones + mc_type = ((_mvY & 1) << 1) | (_mvX & 1); + _mvX >>= 1; + _mvY >>= 1; // convert halfpel vectors into fullpel ones } for (blk = 0; blk < num_blocks; blk++) { // adjust block position in the buffer according with its number - offs = mb->buf_offs + band->blk_size * ((blk & 1) + !!(blk & 2) * band->pitch); + offs = mb->_bufOffs + band->_blkSize * ((blk & 1) + !!(blk & 2) * band->_pitch); ret = ivi_mc(band, mc_no_delta_func, nullptr, offs, - mv_x, mv_y, 0, 0, mc_type, -1); + _mvX, _mvY, 0, 0, mc_type, -1); if (ret < 0) return ret; } } } else { // copy data from the reference tile into the current one - src = band->ref_buf + tile->ypos * band->pitch + tile->xpos; - dst = band->buf + tile->ypos * band->pitch + tile->xpos; - for (y = 0; y < tile->height; y++) { - memcpy(dst, src, tile->width*sizeof(band->buf[0])); - src += band->pitch; - dst += band->pitch; + src = band->_refBuf + tile->_yPos * band->_pitch + tile->_xPos; + dst = band->_buf + tile->_yPos * band->_pitch + tile->_xPos; + for (y = 0; y < tile->_height; y++) { + memcpy(dst, src, tile->_width*sizeof(band->_buf[0])); + src += band->_pitch; + dst += band->_pitch; } } return 0; } -int IndeoDecoderBase::ivi_dec_tile_data_size(GetBits *gb) { +int IndeoDecoderBase::ivi_dec_tile_data_size(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, blk_size, ret, is_intra; +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 mv_x = 0, mv_y = 0, mv_x2 = 0, mv_y2 = 0; + int _mvX = 0, _mvY = 0, mv_x2 = 0, mv_y2 = 0; int32 prev_dc; - uint32 cbp, quant, buf_offs; + uint32 _cbp, quant, _bufOffs; IVIMbInfo *mb; - ivi_mc_func mc_with_delta_func, mc_no_delta_func; - ivi_mc_avg_func mc_avg_with_delta_func, mc_avg_no_delta_func; + IviMCFunc mc_with_delta_func, mc_no_delta_func; + IviMCAvgFunc mc_avg_with_delta_func, mc_avg_no_delta_func; const uint8 *scale_tab; // init intra prediction for the DC coefficient prev_dc = 0; - blk_size = band->blk_size; + _blkSize = band->_blkSize; // number of blocks per mb - num_blocks = (band->mb_size != blk_size) ? 4 : 1; - if (blk_size == 8) { + 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; @@ -1080,65 +1082,65 @@ int IndeoDecoderBase::ivi_decode_blocks(GetBits *gb, IVIBandDesc *band, IVITile mc_avg_no_delta_func = IndeoDSP::ff_ivi_mc_avg_4x4_no_delta; } - for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) { - is_intra = !mb->type; - cbp = mb->cbp; - buf_offs = mb->buf_offs; + for (mbn = 0, mb = tile->_mbs; mbn < tile->_numMBs; mb++, mbn++) { + is_intra = !mb->_type; + _cbp = mb->_cbp; + _bufOffs = mb->_bufOffs; - quant = band->glob_quant + mb->q_delta; - if (_ctx.is_indeo4) + quant = band->_globQuant + mb->_qDelta; + if (_ctx._isIndeo4) quant = av_clip_uintp2(quant, 5); else quant = av_clip((int)quant, 0, 23); - scale_tab = is_intra ? band->intra_scale : band->inter_scale; + scale_tab = is_intra ? band->_intraScale : band->_interScale; if (scale_tab) quant = scale_tab[quant]; if (!is_intra) { - mv_x = mb->mv_x; - mv_y = mb->mv_y; - mv_x2 = mb->b_mv_x; - mv_y2 = mb->b_mv_y; - if (band->is_halfpel) { - mc_type = ((mv_y & 1) << 1) | (mv_x & 1); + _mvX = mb->_mvX; + _mvY = mb->_mvY; + mv_x2 = mb->_bMvX; + mv_y2 = mb->_bMvY; + if (band->_isHalfpel) { + mc_type = ((_mvY & 1) << 1) | (_mvX & 1); mc_type2 = ((mv_y2 & 1) << 1) | (mv_x2 & 1); - mv_x >>= 1; - mv_y >>= 1; + _mvX >>= 1; + _mvY >>= 1; mv_x2 >>= 1; mv_y2 >>= 1; // convert halfpel vectors into fullpel ones } - if (mb->type == 2) + if (mb->_type == 2) mc_type = -1; - if (mb->type != 2 && mb->type != 3) + if (mb->_type != 2 && mb->_type != 3) mc_type2 = -1; - if (mb->type) { + if (mb->_type) { int dmv_x, dmv_y, cx, cy; - dmv_x = mb->mv_x >> band->is_halfpel; - dmv_y = mb->mv_y >> band->is_halfpel; - cx = mb->mv_x & band->is_halfpel; - cy = mb->mv_y & band->is_halfpel; + dmv_x = mb->_mvX >> band->_isHalfpel; + dmv_y = mb->_mvY >> band->_isHalfpel; + cx = mb->_mvX & band->_isHalfpel; + cy = mb->_mvY & band->_isHalfpel; - if (mb->xpos + dmv_x < 0 || - mb->xpos + dmv_x + band->mb_size + cx > band->pitch || - mb->ypos + dmv_y < 0 || - mb->ypos + dmv_y + band->mb_size + cy > band->aheight) { + if (mb->_xPos + dmv_x < 0 || + mb->_xPos + dmv_x + band->_mbSize + cx > band->_pitch || + mb->_yPos + dmv_y < 0 || + mb->_yPos + dmv_y + band->_mbSize + cy > band->_aHeight) { return -1; } } - if (mb->type == 2 || mb->type == 3) { + if (mb->_type == 2 || mb->_type == 3) { int dmv_x, dmv_y, cx, cy; - dmv_x = mb->b_mv_x >> band->is_halfpel; - dmv_y = mb->b_mv_y >> band->is_halfpel; - cx = mb->b_mv_x & band->is_halfpel; - cy = mb->b_mv_y & band->is_halfpel; + dmv_x = mb->_bMvX >> band->_isHalfpel; + dmv_y = mb->_bMvY >> band->_isHalfpel; + cx = mb->_bMvX & band->_isHalfpel; + cy = mb->_bMvY & band->_isHalfpel; - if (mb->xpos + dmv_x < 0 || - mb->xpos + dmv_x + band->mb_size + cx > band->pitch || - mb->ypos + dmv_y < 0 || - mb->ypos + dmv_y + band->mb_size + cy > band->aheight) { + if (mb->_xPos + dmv_x < 0 || + mb->_xPos + dmv_x + band->_mbSize + cx > band->_pitch || + mb->_yPos + dmv_y < 0 || + mb->_yPos + dmv_y + band->_mbSize + cy > band->_aHeight) { return -1; } } @@ -1147,19 +1149,19 @@ int IndeoDecoderBase::ivi_decode_blocks(GetBits *gb, IVIBandDesc *band, IVITile for (blk = 0; blk < num_blocks; blk++) { // adjust block position in the buffer according to its number if (blk & 1) { - buf_offs += blk_size; + _bufOffs += _blkSize; } else if (blk == 2) { - buf_offs -= blk_size; - buf_offs += blk_size * band->pitch; + _bufOffs -= _blkSize; + _bufOffs += _blkSize * band->_pitch; } - if (cbp & 1) { // block coded ? - ret = ivi_decode_coded_blocks(gb, band, mc_with_delta_func, + if (_cbp & 1) { // block coded ? + ret = ivi_decode_coded_blocks(_gb, band, mc_with_delta_func, mc_avg_with_delta_func, - mv_x, mv_y, mv_x2, mv_y2, + _mvX, _mvY, mv_x2, mv_y2, &prev_dc, is_intra, mc_type, mc_type2, quant, - buf_offs); + _bufOffs); if (ret < 0) return ret; } else { @@ -1167,23 +1169,23 @@ int IndeoDecoderBase::ivi_decode_blocks(GetBits *gb, IVIBandDesc *band, IVITile // 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, buf_offs, blk_size); + ret = ivi_dc_transform(band, &prev_dc, _bufOffs, _blkSize); if (ret < 0) return ret; } else { ret = ivi_mc(band, mc_no_delta_func, mc_avg_no_delta_func, - buf_offs, mv_x, mv_y, mv_x2, mv_y2, + _bufOffs, _mvX, _mvY, mv_x2, mv_y2, mc_type, mc_type2); if (ret < 0) return ret; } } - cbp >>= 1; + _cbp >>= 1; }// for blk }// for mbn - gb->alignGetBits(); + _gb->alignGetBits(); return 0; } @@ -1191,65 +1193,65 @@ int IndeoDecoderBase::ivi_scale_mv(int mv, int mv_scale){ return (mv + (mv > 0) + (mv_scale - 1)) >> mv_scale; } -int IndeoDecoderBase::ivi_mc(IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg, - int offs, int mv_x, int mv_y, int mv_x2, int mv_y2, +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 + mv_y * band->pitch + mv_x; - int buf_size = band->pitch * band->aheight; - int min_size = band->pitch * (band->blk_size - 1) + band->blk_size; - int ref_size = (mc_type > 1) * band->pitch + (mc_type & 1); + 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->ref_buf); + assert(offs >= 0 && ref_offs >= 0 && band->_refBuf); assert(buf_size - min_size >= offs); assert(buf_size - min_size - ref_size >= ref_offs); } if (mc_type2 == -1) { - mc(band->buf + offs, band->ref_buf + ref_offs, band->pitch, mc_type); + mc(band->_buf + offs, band->_refBuf + ref_offs, band->_pitch, mc_type); } else { - int ref_offs2 = offs + mv_y2 * band->pitch + mv_x2; - int ref_size2 = (mc_type2 > 1) * band->pitch + (mc_type2 & 1); - if (offs < 0 || ref_offs2 < 0 || !band->b_ref_buf) + int ref_offs2 = offs + mv_y2 * band->_pitch + mv_x2; + int ref_size2 = (mc_type2 > 1) * band->_pitch + (mc_type2 & 1); + if (offs < 0 || ref_offs2 < 0 || !band->_bRefBuf) return -1; if (buf_size - min_size - ref_size2 < ref_offs2) return -1; if (mc_type == -1) - mc(band->buf + offs, band->b_ref_buf + ref_offs2, - band->pitch, mc_type2); + mc(band->_buf + offs, band->_bRefBuf + ref_offs2, + band->_pitch, mc_type2); else - mc_avg(band->buf + offs, band->ref_buf + ref_offs, - band->b_ref_buf + ref_offs2, band->pitch, + mc_avg(band->_buf + offs, band->_refBuf + ref_offs, + band->_bRefBuf + ref_offs2, band->_pitch, mc_type, mc_type2); } return 0; } -int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *gb, IVIBandDesc *band, - ivi_mc_func mc, ivi_mc_avg_func mc_avg, int mv_x, int mv_y, +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->intra_base : band->inter_base; - RVMapDesc *rvmap = band->rv_map; + const uint16 *base_tab = is_intra ? band->_intraBase : band->_interBase; + RVMapDesc *rvmap = band->_rvMap; uint8 col_flags[8]; int32 trvec[64]; uint32 sym = 0, q; int lo, hi; int pos, run, val; - int blk_size = band->blk_size; - int num_coeffs = blk_size * blk_size; - int col_mask = blk_size - 1; + int _blkSize = band->_blkSize; + int num_coeffs = _blkSize * _blkSize; + int col_mask = _blkSize - 1; int scan_pos = -1; - int min_size = band->pitch * (band->transform_size - 1) + - band->transform_size; - int buf_size = band->pitch * band->aheight - offs; + int min_size = band->_pitch * (band->_transformSize - 1) + + band->_transformSize; + int buf_size = band->_pitch * band->_aHeight - offs; if (min_size > buf_size) return -1; - if (!band->scan) { + if (!band->_scan) { warning("Scan pattern is not set."); return -1; } @@ -1259,16 +1261,16 @@ int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *gb, IVIBandDesc *band, // zero column flags memset(col_flags, 0, sizeof(col_flags)); while (scan_pos <= num_coeffs) { - sym = gb->getVLC2(band->blk_vlc.tab->_table, + sym = _gb->getVLC2(band->_blkVlc._tab->_table, IVI_VLC_BITS, 1); - if (sym == rvmap->eob_sym) + if (sym == rvmap->_eobSym) break; // End of block // Escape - run/val explicitly coded using 3 vlc codes - if (sym == rvmap->esc_sym) { - run = gb->getVLC2(band->blk_vlc.tab->_table, IVI_VLC_BITS, 1) + 1; - lo = gb->getVLC2(band->blk_vlc.tab->_table, IVI_VLC_BITS, 1); - hi = gb->getVLC2(band->blk_vlc.tab->_table, IVI_VLC_BITS, 1); + 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); // merge them and convert into signed val val = IVI_TOSIGNED((hi << 6) | lo); } else { @@ -1276,15 +1278,15 @@ int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *gb, IVIBandDesc *band, warning("Invalid sym encountered"); return -1; } - run = rvmap->runtab[sym]; - val = rvmap->valtab[sym]; + run = rvmap->_runtab[sym]; + val = rvmap->_valtab[sym]; } // de-zigzag and dequantize scan_pos += run; if (scan_pos >= num_coeffs || scan_pos < 0) break; - pos = band->scan[scan_pos]; + pos = band->_scan[scan_pos]; if (!val) warning("Val = 0 encountered!"); @@ -1297,43 +1299,43 @@ int IndeoDecoderBase::ivi_decode_coded_blocks(GetBits *gb, IVIBandDesc *band, col_flags[pos & col_mask] |= !!val; } - if (scan_pos < 0 || (scan_pos >= num_coeffs && sym != rvmap->eob_sym)) + if (scan_pos < 0 || (scan_pos >= num_coeffs && sym != rvmap->_eobSym)) return -1; // corrupt block data // undoing DC coeff prediction for intra-blocks - if (is_intra && band->is_2d_trans) { + if (is_intra && band->_is2dTrans) { *prev_dc += trvec[0]; trvec[0] = *prev_dc; col_flags[0] |= !!*prev_dc; } - if (band->transform_size > band->blk_size) { + if (band->_transformSize > band->_blkSize) { warning("Too large transform"); return -1; } // apply inverse transform - band->inv_transform(trvec, band->buf + offs, - band->pitch, col_flags); + band->_invTransform(trvec, band->_buf + offs, + band->_pitch, col_flags); // apply motion compensation if (!is_intra) - return ivi_mc(band, mc, mc_avg, offs, mv_x, mv_y, mv_x2, mv_y2, + return ivi_mc(band, mc, mc_avg, offs, _mvX, _mvY, mv_x2, mv_y2, mc_type, mc_type2); return 0; } int IndeoDecoderBase::ivi_dc_transform(IVIBandDesc *band, int *prev_dc, - int buf_offs, int blk_size) { - int buf_size = band->pitch * band->aheight - buf_offs; - int min_size = (blk_size - 1) * band->pitch + blk_size; + int bufOffs, int blkSize) { + int buf_size = band->_pitch * band->_aHeight - bufOffs; + int min_size = (blkSize - 1) * band->_pitch + blkSize; if (min_size > buf_size) return -1; - band->dc_transform(prev_dc, band->buf + buf_offs, - band->pitch, blk_size); + band->_dcTransform(prev_dc, band->_buf + bufOffs, + band->_pitch, blkSize); return 0; } @@ -1377,8 +1379,8 @@ const uint8 IndeoDecoderBase::_ff_ivi_direct_scan_4x4[16] = { const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { { // MapTab0 - 5, // eob_sym - 2, // esc_sym + 5, // _eobSym + 2, // _escSym // run table {1, 1, 0, 1, 1, 0, 1, 1, 2, 2, 1, 1, 1, 1, 3, 3, 1, 1, 2, 2, 1, 1, 4, 4, 1, 1, 1, 1, 2, 2, 5, 5, @@ -1416,8 +1418,8 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { -1, -2, 2, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1} },{ // MapTab1 - 0, // eob_sym - 38, // esc_sym + 0, // _eobSym + 38, // _escSym // run table {0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 8, 6, 8, 7, 7, 9, 9, 10, 10, 11, 11, 1, 12, 1, 12, 13, 13, 16, 14, 16, @@ -1455,8 +1457,8 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { -5, -4, -3, 4, 2, -3, 3, -2, -5, 5, 3, 3, -2, -3, -10, -4} },{ // MapTab2 - 2, // eob_sym - 11, // esc_sym + 2, // _eobSym + 11, // _escSym // run table {1, 1, 0, 2, 2, 1, 1, 3, 3, 4, 4, 0, 1, 1, 5, 5, 2, 2, 6, 6, 7, 7, 1, 8, 1, 8, 3, 3, 9, 9, 1, 2, @@ -1494,8 +1496,8 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { -6, 1, -1, 1, -16, 1, 7, -1, 1, -1, -6, -3, 6, -7, 3, -1} },{ // MapTab3 - 0, // eob_sym - 35, // esc_sym + 0, // _eobSym + 35, // _escSym // run table {0, 1, 1, 2, 2, 3, 3, 4, 4, 1, 1, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 2, 2, 10, 10, 1, 1, 11, 11, 12, 12, 3, @@ -1533,8 +1535,8 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { -2, 2, 2, 2, -5, 3, 5, 13, -3, 7, -3, -3, -7, 3, -13, 3} },{ // MapTab4 - 0, // eob_sym - 34, // esc_sym + 0, // _eobSym + 34, // _escSym // run table {0, 1, 1, 1, 2, 2, 1, 3, 3, 1, 1, 1, 4, 4, 1, 5, 2, 1, 5, 2, 1, 1, 6, 6, 1, 1, 1, 1, 1, 7, 3, 1, @@ -1572,8 +1574,8 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { 83, -81, 82, -82, 84, -87, -86, 85, -11, -85, 86, -89, 87, -88, 88, 89} },{ // MapTab5 - 2, // eob_sym - 33, // esc_sym + 2, // _eobSym + 33, // _escSym // run table {1, 1, 0, 2, 1, 2, 1, 3, 3, 1, 1, 4, 4, 2, 2, 1, 1, 5, 5, 6, 1, 6, 1, 7, 7, 3, 3, 2, 8, 2, 8, 1, @@ -1611,8 +1613,8 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { -1, -32, 13, 7, 32, 33, -33, -1, -9, -34, 9, 34, -6, 5, 6, -5} },{ // MapTab6 - 2, // eob_sym - 13, // esc_sym + 2, // _eobSym + 13, // _escSym // run table {1, 1, 0, 1, 1, 2, 2, 1, 1, 3, 3, 1, 1, 0, 2, 2, 4, 1, 4, 1, 1, 1, 5, 5, 1, 1, 6, 6, 2, 2, 1, 1, @@ -1650,8 +1652,8 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { 2, 58, 3, 8, -2, 57, -58, -60, -59, -57, -3, 60, 59, -14, 3, 14} },{ // MapTab7 - 2, // eob_sym - 38, // esc_sym + 2, // _eobSym + 38, // _escSym // run table {1, 1, 0, 2, 2, 1, 1, 3, 3, 4, 4, 5, 5, 1, 1, 6, 6, 2, 2, 7, 7, 8, 8, 1, 1, 3, 3, 9, 9, 10, 10, 1, @@ -1689,8 +1691,8 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { 3, -1, 3, -3, -23, 4, -4, 1, 23, -1, 1, -1, 1, -2, 2, -1} },{ // MapTab8 - 4, // eob_sym - 11, // esc_sym + 4, // _eobSym + 11, // _escSym // run table {1, 1, 1, 1, 0, 2, 2, 1, 1, 3, 3, 0, 1, 1, 2, 2, 4, 4, 1, 1, 5, 5, 1, 1, 2, 2, 3, 3, 6, 6, 1, 1, diff --git a/image/codecs/indeo/indeo.h b/image/codecs/indeo/indeo.h index c9d556a92f..b9e46931b0 100644 --- a/image/codecs/indeo/indeo.h +++ b/image/codecs/indeo/indeo.h @@ -64,15 +64,14 @@ enum { * Declare inverse transform function types */ typedef void (InvTransformPtr)(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags); -typedef void (DCTransformPtr) (const int32 *in, int16 *out, uint32 pitch, int blk_size); +typedef void (DCTransformPtr) (const int32 *in, int16 *out, uint32 pitch, int blkSize); -typedef void(*ivi_mc_func) (int16 *buf, const int16 *ref_buf, - uint32 pitch, int mc_type); -typedef void(*ivi_mc_avg_func) (int16 *buf, const int16 *ref_buf1, - const int16 *ref_buf2, - uint32 pitch, int mc_type, int mc_type2); +typedef void(*IviMCFunc) (int16 *buf, const int16 *refBuf, uint32 pitch, int mc_type); +typedef void(*IviMCAvgFunc) (int16 *buf, const int16 *refBuf1, const int16 *refBuf2, + uint32 pitch, int mcType, int mcType2); -#define IVI_VLC_BITS 13 ///< max number of bits of the ivi's huffman codes +///< max number of bits of the ivi's huffman codes +#define IVI_VLC_BITS 13 #define IVI5_IS_PROTECTED 0x20 /** @@ -83,15 +82,15 @@ typedef void(*ivi_mc_avg_func) (int16 *buf, const int16 *ref_buf1, /** * calculate number of macroblocks in a tile */ -#define IVI_MBs_PER_TILE(tile_width, tile_height, mb_size) \ - ((((tile_width) + (mb_size) - 1) / (mb_size)) * (((tile_height) + (mb_size) - 1) / (mb_size))) +#define IVI_MBs_PER_TILE(_tileWidth, _tileHeight, _mbSize) \ + ((((_tileWidth) + (_mbSize) - 1) / (_mbSize)) * (((_tileHeight) + (_mbSize) - 1) / (_mbSize))) /** * huffman codebook descriptor */ struct IVIHuffDesc { - int32 num_rows; - uint8 xbits[16]; + int32 _numRows; + uint8 _xBits[16]; /* * Generate a huffman codebook from the given descriptor @@ -126,13 +125,13 @@ struct IVI45DecContext; */ struct IVIHuffTab { public: - int32 tab_sel; /// index of one of the predefined tables + int32 _tabSel; /// index of one of the predefined tables /// or "7" for custom one - VLC *tab; /// pointer to the table associated with tab_sel + VLC * _tab; /// pointer to the table associated with tab_sel /// the following are used only when tab_sel == 7 - IVIHuffDesc cust_desc; /// custom Huffman codebook descriptor - VLC cust_tab; /// vlc table for custom codebook + IVIHuffDesc _custDesc; /// custom Huffman codebook descriptor + VLC _custTab; /// vlc table for custom codebook /** * Constructor @@ -146,26 +145,26 @@ public: * run-value (RLE) table descriptor */ struct RVMapDesc { - uint8 eob_sym; ///< end of block symbol - uint8 esc_sym; ///< escape symbol - uint8 runtab[256]; - int8 valtab[256]; + uint8 _eobSym; ///< end of block symbol + uint8 _escSym; ///< escape symbol + uint8 _runtab[256]; + int8 _valtab[256]; }; /** * information for Indeo macroblock (16x16, 8x8 or 4x4) */ struct IVIMbInfo { - int16 xpos; - int16 ypos; - uint32 buf_offs; ///< address in the output buffer for this mb - uint8 type; ///< macroblock type: 0 - INTRA, 1 - INTER - uint8 cbp; ///< coded block pattern - int8 q_delta; ///< quant delta - int8 mv_x; ///< motion vector (x component) - int8 mv_y; ///< motion vector (y component) - int8 b_mv_x; ///< second motion vector (x component) - int8 b_mv_y; ///< second motion vector (y component) + int16 _xPos; + int16 _yPos; + uint32 _bufOffs; ///< address in the output buffer for this mb + uint8 _type; ///< macroblock type: 0 - INTRA, 1 - INTER + uint8 _cbp; ///< coded block pattern + int8 _qDelta; ///< quant delta + int8 _mvX; ///< motion vector (x component) + int8 _mvY; ///< motion vector (y component) + int8 _bMvX; ///< second motion vector (x component) + int8 _bMvY; ///< second motion vector (y component) IVIMbInfo(); }; @@ -174,16 +173,16 @@ struct IVIMbInfo { * information for Indeo tile */ struct IVITile { - int xpos; - int ypos; - int width; - int height; - int mb_size; - int is_empty; ///< = 1 if this tile doesn't contain any data - int data_size; ///< size of the data in bytes - int num_MBs; ///< number of macroblocks in this tile - IVIMbInfo * mbs; ///< array of macroblock descriptors - IVIMbInfo * ref_mbs; ///< ptr to the macroblock descriptors of the reference tile + int _xPos; + int _yPos; + int _width; + int _height; + int _mbSize; + bool _isEmpty; + int _dataSize; ///< size of the data in bytes + int _numMBs; ///< number of macroblocks in this tile + IVIMbInfo * _mbs; ///< array of macroblock descriptors + IVIMbInfo * _refMbs; ///< ptr to the macroblock descriptors of the reference tile IVITile(); }; @@ -192,49 +191,49 @@ struct IVITile { * information for Indeo wavelet band */ struct IVIBandDesc { - int plane; ///< plane number this band belongs to - int band_num; ///< band number - int width; - int height; - int aheight; ///< aligned band height - const uint8 * data_ptr; ///< ptr to the first byte of the band data - int data_size; ///< size of the band data - int16 * buf; ///< pointer to the output buffer for this band - int16 * ref_buf; ///< pointer to the reference frame buffer (for motion compensation) - int16 * b_ref_buf; ///< pointer to the second reference frame buffer (for motion compensation) - int16 * bufs[4]; ///< array of pointers to the band buffers - int pitch; ///< pitch associated with the buffers above - int is_empty; ///< = 1 if this band doesn't contain any data - int mb_size; ///< macroblock size - int blk_size; ///< block size - int is_halfpel; ///< precision of the motion compensation: 0 - fullpel, 1 - halfpel - int inherit_mv; ///< tells if motion vector is inherited from reference macroblock - int inherit_qdelta; ///< tells if quantiser delta is inherited from reference macroblock - int qdelta_present; ///< tells if Qdelta signal is present in the bitstream (Indeo5 only) - int quant_mat; ///< dequant matrix index - int glob_quant; ///< quant base for this band - const uint8 * scan; ///< ptr to the scan pattern - int scan_size; ///< size of the scantable - - IVIHuffTab blk_vlc; ///< vlc table for decoding block data - - int num_corr; ///< number of correction entries - uint8 corr[61 * 2]; ///< rvmap correction pairs - int rvmap_sel; ///< rvmap table selector - RVMapDesc * rv_map; ///< ptr to the RLE table for this band - int num_tiles; ///< number of tiles in this band - IVITile * tiles; ///< array of tile descriptors - InvTransformPtr *inv_transform; - int transform_size; - DCTransformPtr *dc_transform; - int is_2d_trans; ///< 1 indicates that the two-dimensional inverse transform is used - int32 checksum; ///< for debug purposes - int checksum_present; - int bufsize; ///< band buffer size in bytes - const uint16 * intra_base; ///< quantization matrix for intra blocks - const uint16 * inter_base; ///< quantization matrix for inter blocks - const uint8 * intra_scale; ///< quantization coefficient for intra blocks - const uint8 * inter_scale; ///< quantization coefficient for inter blocks + int _plane; ///< plane number this band belongs to + int _bandNum; ///< band number + int _width; + int _height; + int _aHeight; ///< aligned band height + const uint8 * _dataPtr; ///< ptr to the first byte of the band data + int _dataSize; ///< size of the band data + int16 * _buf; ///< pointer to the output buffer for this band + int16 * _refBuf; ///< pointer to the reference frame buffer (for motion compensation) + int16 * _bRefBuf; ///< pointer to the second reference frame buffer (for motion compensation) + int16 * _bufs[4]; ///< array of pointers to the band buffers + int _pitch; ///< _pitch associated with the buffers above + bool _isEmpty; + int _mbSize; ///< macroblock size + int _blkSize; ///< block size + uint8 _isHalfpel; ///< precision of the motion compensation: 0 - fullpel, 1 - halfpel + bool _inheritMv; ///< tells if motion vector is inherited from reference macroblock + bool _inheritQDelta; ///< tells if quantiser delta is inherited from reference macroblock + bool _qdeltaPresent; ///< tells if Qdelta signal is present in the bitstream (Indeo5 only) + int _quantMat; ///< dequant matrix index + int _globQuant; ///< quant base for this band + const uint8 * _scan; ///< ptr to the scan pattern + int _scanSize; ///< size of the scantable + + IVIHuffTab _blkVlc; ///< vlc table for decoding block data + + int _numCorr; ///< number of correction entries + uint8 _corr[61 * 2]; ///< rvmap correction pairs + int _rvmapSel; ///< rvmap table selector + RVMapDesc * _rvMap; ///< ptr to the RLE table for this band + int _numTiles; ///< number of tiles in this band + IVITile * _tiles; ///< array of tile descriptors + InvTransformPtr *_invTransform; + int _transformSize; + DCTransformPtr *_dcTransform; + bool _is2dTrans; + int32 _checksum; ///< for debug purposes + int _checksumPresent; + int _bufSize; ///< band buffer size in bytes + const uint16 * _intraBase; ///< quantization matrix for intra blocks + const uint16 * _interBase; ///< quantization matrix for inter blocks + const uint8 * _intraScale; ///< quantization coefficient for intra blocks + const uint8 * _interScale; ///< quantization coefficient for inter blocks IVIBandDesc(); @@ -242,14 +241,14 @@ struct IVIBandDesc { }; struct IVIPicConfig { - uint16 pic_width; - uint16 pic_height; - uint16 chroma_width; - uint16 chroma_height; - uint16 tile_width; - uint16 tile_height; - uint8 luma_bands; - uint8 chroma_bands; + uint16 _picWidth; + uint16 _picHeight; + uint16 _chromaWidth; + uint16 _chromaHeight; + uint16 _tileWidth; + uint16 _tileHeight; + uint8 _lumaBands; + uint8 _chromaBands; IVIPicConfig(); @@ -263,16 +262,16 @@ struct IVIPicConfig { * color plane (luma or chroma) information */ struct IVIPlaneDesc { - uint16 width; - uint16 height; - uint8 num_bands; ///< number of bands this plane subdivided into - IVIBandDesc *bands; ///< array of band descriptors + uint16 _width; + uint16 _height; + uint8 _numBands; ///< number of bands this plane subdivided into + IVIBandDesc * _bands; ///< array of band descriptors IVIPlaneDesc(); - static int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool is_indeo4); + static int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool _isIndeo4); - static int ff_ivi_init_tiles(IVIPlaneDesc *planes, int tile_width, int tile_height); + static int ff_ivi_init_tiles(IVIPlaneDesc *planes, int _tileWidth, int _tileHeight); /* * Free planes, bands and macroblocks buffers. @@ -349,60 +348,60 @@ struct AVFrame { struct IVI45DecContext { friend struct IVIHuffTab; private: - VLC_TYPE table_data[8192 * 16][2]; - VLC ivi_mb_vlc_tabs[8]; ///< static macroblock Huffman tables - VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables + VLC_TYPE _tableData[8192 * 16][2]; + VLC _iviMbVlcTabs[8]; ///< static macroblock Huffman tables + VLC _iviBlkVlcTabs[8]; ///< static block Huffman tables public: - GetBits * gb; - RVMapDesc rvmap_tabs[9]; ///< local corrected copy of the static rvmap tables - - uint32 frame_num; - int frame_type; - int prev_frame_type; ///< frame type of the previous frame - uint32 data_size; ///< size of the frame data in bytes from picture header - int is_scalable; - const uint8 * frame_data; ///< input frame data pointer - int inter_scal; ///< signals a sequence of scalable inter frames - uint32 frame_size; ///< frame size in bytes - uint32 pic_hdr_size; ///< picture header size in bytes - uint8 frame_flags; - uint16 checksum; ///< frame checksum - - IVIPicConfig pic_conf; - IVIPlaneDesc planes[3]; ///< color planes - - int buf_switch; ///< used to switch between three buffers - int dst_buf; ///< buffer index for the currently decoded frame - int ref_buf; ///< inter frame reference buffer index - int ref2_buf; ///< temporal storage for switching buffers - int b_ref_buf; ///< second reference frame buffer index - - IVIHuffTab mb_vlc; ///< current macroblock table descriptor - IVIHuffTab blk_vlc; ///< current block table descriptor - - uint8 rvmap_sel; - uint8 in_imf; - uint8 in_q; ///< flag for explicitly stored quantiser delta - uint8 pic_glob_quant; - uint8 unknown1; - - uint16 gop_hdr_size; - uint8 gop_flags; - uint32 lock_word; - - uint8 has_b_frames; - uint8 has_transp; ///< transparency mode status: 1 - enabled - uint8 uses_tiling; - uint8 uses_haar; - uint8 uses_fullpel; - - int gop_invalid; - int buf_invalid[4]; - - int is_indeo4; - - AVFrame * p_frame; - int got_p_frame; + GetBits * _gb; + RVMapDesc _rvmapTabs[9]; ///< local corrected copy of the static rvmap tables + + uint32 _frameNum; + int _frameType; + int _prevFrameType; ///< frame type of the previous frame + uint32 _dataSize; ///< size of the frame data in bytes from picture header + int _isScalable; + const uint8 * _frameData; ///< input frame data pointer + int _interScal; ///< signals a sequence of scalable inter frames + uint32 _frameSize; ///< frame size in bytes + uint32 _picHdrSize; ///< picture header size in bytes + uint8 _frameFlags; + uint16 _checksum; ///< frame _checksum + + IVIPicConfig _picConf; + IVIPlaneDesc _planes[3]; ///< color planes + + int _bufSwitch; ///< used to switch between three buffers + int _dstBuf; ///< buffer index for the currently decoded frame + int _refBuf; ///< inter frame reference buffer index + int _ref2Buf; ///< temporal storage for switching buffers + int _bRefBuf; ///< second reference frame buffer index + + IVIHuffTab _mbVlc; ///< current macroblock table descriptor + IVIHuffTab _blkVlc; ///< current block table descriptor + + uint8 _rvmapSel; + bool _inImf; + bool _inQ; ///< flag for explicitly stored quantiser delta + uint8 _picGlobQuant; + uint8 _unknown1; + + uint16 _gopHdrSize; + uint8 _gopFlags; + uint32 _lockWord; + + bool _hasBFrames; + bool _hasTransp; ///< transparency mode enabled + bool _usesTiling; + bool _usesHaar; + bool _usesFullpel; + + bool _gopInvalid; + int _bufInvalid[4]; + + bool _isIndeo4; + + AVFrame * _pFrame; + bool _gotPFrame; IVI45DecContext(); private: @@ -427,7 +426,7 @@ private: * * @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] dst_pitch _pitch of the destination buffer */ void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8 *dst, const int dst_pitch); @@ -437,7 +436,7 @@ private: * * @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] dst_pitch _pitch of the destination buffer */ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8 *dst, const int dst_pitch); @@ -449,7 +448,7 @@ private: * * @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] dst_pitch _pitch for moving to the next y line */ void ivi_output_plane(IVIPlaneDesc *plane, uint8 *dst, int dst_pitch); @@ -488,17 +487,17 @@ private: */ int ivi_decode_blocks(GetBits *gb, IVIBandDesc *band, IVITile *tile); - int ivi_mc(IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg, - int offs, int mv_x, int mv_y, int mv_x2, int mv_y2, + 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 ivi_decode_coded_blocks(GetBits *gb, IVIBandDesc *band, - ivi_mc_func mc, ivi_mc_avg_func mc_avg, int mv_x, int mv_y, + 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); - int ivi_dc_transform(IVIBandDesc *band, int *prev_dc, int buf_offs, - int blk_size); + int ivi_dc_transform(IVIBandDesc *band, int *prevDc, int bufOffs, + int blkSize); protected: IVI45DecContext _ctx; Graphics::PixelFormat _pixelFormat; @@ -538,7 +537,7 @@ protected: virtual int decode_band_hdr(IVIBandDesc *band) = 0; /** - * Decode information (block type, cbp, quant delta, motion vector) + * 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 diff --git a/image/codecs/indeo4.cpp b/image/codecs/indeo4.cpp index 7e0a4516d1..12ab988bda 100644 --- a/image/codecs/indeo4.cpp +++ b/image/codecs/indeo4.cpp @@ -41,10 +41,10 @@ namespace Image { #define IVI4_PIC_SIZE_ESC 7 Indeo4Decoder::Indeo4Decoder(uint16 width, uint16 height) : IndeoDecoderBase(width, height) { - _ctx.is_indeo4 = true; - _ctx.ref_buf = 1; - _ctx.b_ref_buf = 3; - _ctx.p_frame = new AVFrame(); + _ctx._isIndeo4 = true; + _ctx._refBuf = 1; + _ctx._bRefBuf = 3; + _ctx._pFrame = new AVFrame(); } bool Indeo4Decoder::isIndeo4(Common::SeekableReadStream &stream) { @@ -72,56 +72,56 @@ const Graphics::Surface *Indeo4Decoder::decodeFrame(Common::SeekableReadStream & // Set up the frame data buffer byte *frameData = new byte[stream.size()]; stream.read(frameData, stream.size()); - _ctx.frame_data = frameData; - _ctx.frame_size = stream.size(); + _ctx._frameData = frameData; + _ctx._frameSize = stream.size(); // Set up the GetBits instance for reading the data - _ctx.gb = new GetBits(_ctx.frame_data, _ctx.frame_size * 8); + _ctx._gb = new GetBits(_ctx._frameData, _ctx._frameSize * 8); // Decode the frame int err = decodeIndeoFrame(); // Free the bit reader and frame buffer - delete _ctx.gb; - _ctx.gb = nullptr; + delete _ctx._gb; + _ctx._gb = nullptr; delete[] frameData; - _ctx.frame_data = nullptr; - _ctx.frame_size = 0; + _ctx._frameData = nullptr; + _ctx._frameSize = 0; return (err < 0) ? nullptr : &_surface->rawSurface(); } int Indeo4Decoder::decodePictureHeader() { int pic_size_indx, i, p; - IVIPicConfig pic_conf; + IVIPicConfig _picConf; - if (_ctx.gb->getBits(18) != 0x3FFF8) { + if (_ctx._gb->getBits(18) != 0x3FFF8) { warning("Invalid picture start code!"); return -1; } - _ctx.prev_frame_type = _ctx.frame_type; - _ctx.frame_type = _ctx.gb->getBits(3); - if (_ctx.frame_type == 7) { - warning("Invalid frame type: %d", _ctx.frame_type); + _ctx._prevFrameType = _ctx._frameType; + _ctx._frameType = _ctx._gb->getBits(3); + if (_ctx._frameType == 7) { + warning("Invalid frame type: %d", _ctx._frameType); return -1; } - if (_ctx.frame_type == IVI4_FRAMETYPE_BIDIR) - _ctx.has_b_frames = 1; + if (_ctx._frameType == IVI4_FRAMETYPE_BIDIR) + _ctx._hasBFrames = true; - _ctx.has_transp = _ctx.gb->getBits1(); + _ctx._hasTransp = _ctx._gb->getBits1(); // unknown bit: Mac decoder ignores this bit, XANIM returns error - if (_ctx.gb->getBits1()) { + if (_ctx._gb->getBits1()) { warning("Sync bit is set!"); return -1; } - _ctx.data_size = _ctx.gb->getBits1() ? _ctx.gb->getBits(24) : 0; + _ctx._dataSize = _ctx._gb->getBits1() ? _ctx._gb->getBits(24) : 0; // null frames don't contain anything else so we just return - if (_ctx.frame_type >= IVI4_FRAMETYPE_NULL_FIRST) { + if (_ctx._frameType >= IVI4_FRAMETYPE_NULL_FIRST) { warning("Null frame encountered!"); return 0; } @@ -129,108 +129,108 @@ int Indeo4Decoder::decodePictureHeader() { // Check key lock status. If enabled - ignore lock word. // Usually we have to prompt the user for the password, but // we don't do that because Indeo 4 videos can be decoded anyway - if (_ctx.gb->getBits1()) { - _ctx.gb->skipBitsLong(32); + if (_ctx._gb->getBits1()) { + _ctx._gb->skipBitsLong(32); warning("Password-protected clip!"); } - pic_size_indx = _ctx.gb->getBits(3); + pic_size_indx = _ctx._gb->getBits(3); if (pic_size_indx == IVI4_PIC_SIZE_ESC) { - pic_conf.pic_height = _ctx.gb->getBits(16); - pic_conf.pic_width = _ctx.gb->getBits(16); + _picConf._picHeight = _ctx._gb->getBits(16); + _picConf._picWidth = _ctx._gb->getBits(16); } else { - pic_conf.pic_height = _ivi4_common_pic_sizes[pic_size_indx * 2 + 1]; - pic_conf.pic_width = _ivi4_common_pic_sizes[pic_size_indx * 2]; + _picConf._picHeight = _ivi4_common_pic_sizes[pic_size_indx * 2 + 1]; + _picConf._picWidth = _ivi4_common_pic_sizes[pic_size_indx * 2]; } // Decode tile dimensions. - _ctx.uses_tiling = _ctx.gb->getBits1(); - if (_ctx.uses_tiling) { - pic_conf.tile_height = scaleTileSize(pic_conf.pic_height, _ctx.gb->getBits(4)); - pic_conf.tile_width = scaleTileSize(pic_conf.pic_width, _ctx.gb->getBits(4)); + _ctx._usesTiling = _ctx._gb->getBits1(); + if (_ctx._usesTiling) { + _picConf._tileHeight = scaleTileSize(_picConf._picHeight, _ctx._gb->getBits(4)); + _picConf._tileWidth = scaleTileSize(_picConf._picWidth, _ctx._gb->getBits(4)); } else { - pic_conf.tile_height = pic_conf.pic_height; - pic_conf.tile_width = pic_conf.pic_width; + _picConf._tileHeight = _picConf._picHeight; + _picConf._tileWidth = _picConf._picWidth; } // Decode chroma subsampling. We support only 4:4 aka YVU9. - if (_ctx.gb->getBits(2)) { + if (_ctx._gb->getBits(2)) { warning("Only YVU9 picture format is supported!"); return -1; } - pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2; - pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2; + _picConf._chromaHeight = (_picConf._picHeight + 3) >> 2; + _picConf._chromaWidth = (_picConf._picWidth + 3) >> 2; // decode subdivision of the planes - pic_conf.luma_bands = decodePlaneSubdivision(); - pic_conf.chroma_bands = 0; - if (pic_conf.luma_bands) - pic_conf.chroma_bands = decodePlaneSubdivision(); - _ctx.is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1; - if (_ctx.is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) { + _picConf._lumaBands = decodePlaneSubdivision(); + _picConf._chromaBands = 0; + if (_picConf._lumaBands) + _picConf._chromaBands = decodePlaneSubdivision(); + _ctx._isScalable = _picConf._lumaBands != 1 || _picConf._chromaBands != 1; + if (_ctx._isScalable && (_picConf._lumaBands != 4 || _picConf._chromaBands != 1)) { warning("Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d", - pic_conf.luma_bands, pic_conf.chroma_bands); + _picConf._lumaBands, _picConf._chromaBands); return -1; } // check if picture layout was changed and reallocate buffers - if (pic_conf.ivi_pic_config_cmp(_ctx.pic_conf)) { - if (IVIPlaneDesc::ff_ivi_init_planes(_ctx.planes, &pic_conf, 1)) { + if (_picConf.ivi_pic_config_cmp(_ctx._picConf)) { + if (IVIPlaneDesc::ff_ivi_init_planes(_ctx._planes, &_picConf, 1)) { warning("Couldn't reallocate color planes!"); - _ctx.pic_conf.luma_bands = 0; + _ctx._picConf._lumaBands = 0; return -2; } - _ctx.pic_conf = pic_conf; + _ctx._picConf = _picConf; // set default macroblock/block dimensions for (p = 0; p <= 2; p++) { - for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) { - _ctx.planes[p].bands[i].mb_size = !p ? (!_ctx.is_scalable ? 16 : 8) : 4; - _ctx.planes[p].bands[i].blk_size = !p ? 8 : 4; + for (i = 0; i < (!p ? _picConf._lumaBands : _picConf._chromaBands); i++) { + _ctx._planes[p]._bands[i]._mbSize = !p ? (!_ctx._isScalable ? 16 : 8) : 4; + _ctx._planes[p]._bands[i]._blkSize = !p ? 8 : 4; } } - if (IVIPlaneDesc::ff_ivi_init_tiles(_ctx.planes, _ctx.pic_conf.tile_width, - _ctx.pic_conf.tile_height)) { + if (IVIPlaneDesc::ff_ivi_init_tiles(_ctx._planes, _ctx._picConf._tileWidth, + _ctx._picConf._tileHeight)) { warning("Couldn't reallocate internal structures!"); return -2; } } - _ctx.frame_num = _ctx.gb->getBits1() ? _ctx.gb->getBits(20) : 0; + _ctx._frameNum = _ctx._gb->getBits1() ? _ctx._gb->getBits(20) : 0; // skip decTimeEst field if present - if (_ctx.gb->getBits1()) - _ctx.gb->skipBits(8); + if (_ctx._gb->getBits1()) + _ctx._gb->skipBits(8); // decode macroblock and block huffman codebooks - if (_ctx.mb_vlc.ff_ivi_dec_huff_desc(&_ctx, _ctx.gb->getBits1(), IVI_MB_HUFF) || - _ctx.blk_vlc.ff_ivi_dec_huff_desc(&_ctx, _ctx.gb->getBits1(), IVI_BLK_HUFF)) + 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)) return -1; - _ctx.rvmap_sel = _ctx.gb->getBits1() ? _ctx.gb->getBits(3) : 8; + _ctx._rvmapSel = _ctx._gb->getBits1() ? _ctx._gb->getBits(3) : 8; - _ctx.in_imf = _ctx.gb->getBits1(); - _ctx.in_q = _ctx.gb->getBits1(); + _ctx._inImf = _ctx._gb->getBits1(); + _ctx._inQ = _ctx._gb->getBits1(); - _ctx.pic_glob_quant = _ctx.gb->getBits(5); + _ctx._picGlobQuant = _ctx._gb->getBits(5); // TODO: ignore this parameter if unused - _ctx.unknown1 = _ctx.gb->getBits1() ? _ctx.gb->getBits(3) : 0; + _ctx._unknown1 = _ctx._gb->getBits1() ? _ctx._gb->getBits(3) : 0; - _ctx.checksum = _ctx.gb->getBits1() ? _ctx.gb->getBits(16) : 0; + _ctx._checksum = _ctx._gb->getBits1() ? _ctx._gb->getBits(16) : 0; // skip picture header extension if any - while (_ctx.gb->getBits1()) { - _ctx.gb->skipBits(8); + while (_ctx._gb->getBits1()) { + _ctx._gb->skipBits(8); } - if (_ctx.gb->getBits1()) { + if (_ctx._gb->getBits1()) { warning("Bad blocks bits encountered!"); } - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); return 0; } @@ -238,7 +238,7 @@ int Indeo4Decoder::decodePictureHeader() { void Indeo4Decoder::switch_buffers() { int is_prev_ref = 0, is_ref = 0; - switch (_ctx.prev_frame_type) { + switch (_ctx._prevFrameType) { case IVI4_FRAMETYPE_INTRA: case IVI4_FRAMETYPE_INTRA1: case IVI4_FRAMETYPE_INTER: @@ -246,7 +246,7 @@ void Indeo4Decoder::switch_buffers() { break; } - switch (_ctx.frame_type) { + switch (_ctx._frameType) { case IVI4_FRAMETYPE_INTRA: case IVI4_FRAMETYPE_INTRA1: case IVI4_FRAMETYPE_INTER: @@ -258,67 +258,67 @@ void Indeo4Decoder::switch_buffers() { } if (is_prev_ref && is_ref) { - FFSWAP(int, _ctx.dst_buf, _ctx.ref_buf); + FFSWAP(int, _ctx._dstBuf, _ctx._refBuf); } else if (is_prev_ref) { - FFSWAP(int, _ctx.ref_buf, _ctx.b_ref_buf); - FFSWAP(int, _ctx.dst_buf, _ctx.ref_buf); + FFSWAP(int, _ctx._refBuf, _ctx._bRefBuf); + FFSWAP(int, _ctx._dstBuf, _ctx._refBuf); } } bool Indeo4Decoder::is_nonnull_frame() const { - return _ctx.frame_type < IVI4_FRAMETYPE_NULL_FIRST; + return _ctx._frameType < IVI4_FRAMETYPE_NULL_FIRST; } int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { - int plane, band_num, indx, transform_id, scan_indx; + int plane, _bandNum, indx, transform_id, scan_indx; int i; - int quant_mat; + int _quantMat; - plane = _ctx.gb->getBits(2); - band_num = _ctx.gb->getBits(4); - if (band->plane != plane || band->band_num != band_num) { + plane = _ctx._gb->getBits(2); + _bandNum = _ctx._gb->getBits(4); + if (band->_plane != plane || band->_bandNum != _bandNum) { warning("Invalid band header sequence!"); return -1; } - band->is_empty = _ctx.gb->getBits1(); - if (!band->is_empty) { - int old_blk_size = band->blk_size; + band->_isEmpty = _ctx._gb->getBits1(); + if (!band->_isEmpty) { + int old_blk_size = band->_blkSize; // skip header size // If header size is not given, header size is 4 bytes. - if (_ctx.gb->getBits1()) - _ctx.gb->skipBits(16); + if (_ctx._gb->getBits1()) + _ctx._gb->skipBits(16); - band->is_halfpel = _ctx.gb->getBits(2); - if (band->is_halfpel >= 2) { + band->_isHalfpel = _ctx._gb->getBits(2); + if (band->_isHalfpel >= 2) { warning("Invalid/unsupported mv resolution: %d!", - band->is_halfpel); + band->_isHalfpel); return -1; } - if (!band->is_halfpel) - _ctx.uses_fullpel = 1; + if (!band->_isHalfpel) + _ctx._usesFullpel = true; - band->checksum_present = _ctx.gb->getBits1(); - if (band->checksum_present) - band->checksum = _ctx.gb->getBits(16); + band->_checksumPresent = _ctx._gb->getBits1(); + if (band->_checksumPresent) + band->_checksum = _ctx._gb->getBits(16); - indx = _ctx.gb->getBits(2); + indx = _ctx._gb->getBits(2); if (indx == 3) { warning("Invalid block size!"); return -1; } - band->mb_size = 16 >> indx; - band->blk_size = 8 >> (indx >> 1); + band->_mbSize = 16 >> indx; + band->_blkSize = 8 >> (indx >> 1); - band->inherit_mv = _ctx.gb->getBits1(); - band->inherit_qdelta = _ctx.gb->getBits1(); + band->_inheritMv = _ctx._gb->getBits1(); + band->_inheritQDelta = _ctx._gb->getBits1(); - band->glob_quant = _ctx.gb->getBits(5); + band->_globQuant = _ctx._gb->getBits(5); - if (!_ctx.gb->getBits1() || _ctx.frame_type == IVI4_FRAMETYPE_INTRA) { - transform_id = _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].inv_trans) { + !_transforms[transform_id]._invTrans) { warning("Transform %d", transform_id); return -3; } @@ -328,117 +328,117 @@ int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { return -3; } - if (transform_id < 10 && band->blk_size < 8) { + if (transform_id < 10 && band->_blkSize < 8) { warning("wrong transform size!"); return -1; } if ((transform_id >= 0 && transform_id <= 2) || transform_id == 10) - _ctx.uses_haar = 1; + _ctx._usesHaar = true; - band->inv_transform = _transforms[transform_id].inv_trans; - band->dc_transform = _transforms[transform_id].dc_trans; - band->is_2d_trans = _transforms[transform_id].is_2d_trans; + band->_invTransform = _transforms[transform_id]._invTrans; + band->_dcTransform = _transforms[transform_id]._dcTrans; + band->_is2dTrans = _transforms[transform_id]._is2dTrans; if (transform_id < 10) - band->transform_size = 8; + band->_transformSize = 8; else - band->transform_size = 4; + band->_transformSize = 4; - if (band->blk_size != band->transform_size) { - warning("transform and block size mismatch (%d != %d)", band->transform_size, band->blk_size); + if (band->_blkSize != band->_transformSize) { + warning("transform and block size mismatch (%d != %d)", band->_transformSize, band->_blkSize); return -1; } - scan_indx = _ctx.gb->getBits(4); + scan_indx = _ctx._gb->getBits(4); if (scan_indx == 15) { warning("Custom scan pattern encountered!"); return -1; } if (scan_indx > 4 && scan_indx < 10) { - if (band->blk_size != 4) { + if (band->_blkSize != 4) { warning("mismatching scan table!"); return -1; } - } else if (band->blk_size != 8) { + } else if (band->_blkSize != 8) { warning("mismatching scan table!"); return -1; } - band->scan = _scan_index_to_tab[scan_indx]; - band->scan_size = band->blk_size; + band->_scan = _scan_index_to_tab[scan_indx]; + band->_scanSize = band->_blkSize; - quant_mat = _ctx.gb->getBits(5); - if (quant_mat == 31) { + _quantMat = _ctx._gb->getBits(5); + if (_quantMat == 31) { warning("Custom quant matrix encountered!"); return -1; } - if ((uint)quant_mat >= FF_ARRAY_ELEMS(_quant_index_to_tab)) { - warning("Quantization matrix %d", quant_mat); + if ((uint)_quantMat >= FF_ARRAY_ELEMS(_quant_index_to_tab)) { + warning("Quantization matrix %d", _quantMat); return -1; } - band->quant_mat = quant_mat; + band->_quantMat = _quantMat; } else { - if (old_blk_size != band->blk_size) { + if (old_blk_size != band->_blkSize) { warning("The band block size does not match the configuration inherited"); return -1; } } - if (_quant_index_to_tab[band->quant_mat] > 4 && band->blk_size == 4) { + if (_quant_index_to_tab[band->_quantMat] > 4 && band->_blkSize == 4) { warning("Invalid quant matrix for 4x4 block encountered!"); - band->quant_mat = 0; + band->_quantMat = 0; return -1; } - if (band->scan_size != band->blk_size) { + if (band->_scanSize != band->_blkSize) { warning("mismatching scan table!"); return -1; } - if (band->transform_size == 8 && band->blk_size < 8) { - warning("mismatching transform_size!"); + if (band->_transformSize == 8 && band->_blkSize < 8) { + warning("mismatching _transformSize!"); return -1; } // decode block huffman codebook - if (!_ctx.gb->getBits1()) - band->blk_vlc.tab = _ctx.blk_vlc.tab; + if (!_ctx._gb->getBits1()) + band->_blkVlc._tab = _ctx._blkVlc._tab; else - if (band->blk_vlc.ff_ivi_dec_huff_desc(&_ctx, 1, IVI_BLK_HUFF)) + if (band->_blkVlc.ff_ivi_dec_huff_desc(&_ctx, 1, IVI_BLK_HUFF)) return -1; // select appropriate rvmap table for this band - band->rvmap_sel = _ctx.gb->getBits1() ? _ctx.gb->getBits(3) : 8; + band->_rvmapSel = _ctx._gb->getBits1() ? _ctx._gb->getBits(3) : 8; // decode rvmap probability corrections if any - band->num_corr = 0; // there is no corrections - if (_ctx.gb->getBits1()) { - band->num_corr = _ctx.gb->getBits(8); // get number of correction pairs - if (band->num_corr > 61) { + band->_numCorr = 0; // there is no corrections + if (_ctx._gb->getBits1()) { + band->_numCorr = _ctx._gb->getBits(8); // get number of correction pairs + if (band->_numCorr > 61) { warning("Too many corrections: %d", - band->num_corr); + band->_numCorr); return -1; } // read correction pairs - for (i = 0; i < band->num_corr * 2; i++) - band->corr[i] = _ctx.gb->getBits(8); + for (i = 0; i < band->_numCorr * 2; i++) + band->_corr[i] = _ctx._gb->getBits(8); } } - if (band->blk_size == 8) { - band->intra_base = &_ivi4_quant_8x8_intra[_quant_index_to_tab[band->quant_mat]][0]; - band->inter_base = &_ivi4_quant_8x8_inter[_quant_index_to_tab[band->quant_mat]][0]; + if (band->_blkSize == 8) { + band->_intraBase = &_ivi4_quant_8x8_intra[_quant_index_to_tab[band->_quantMat]][0]; + band->_interBase = &_ivi4_quant_8x8_inter[_quant_index_to_tab[band->_quantMat]][0]; } else { - band->intra_base = &_ivi4_quant_4x4_intra[_quant_index_to_tab[band->quant_mat]][0]; - band->inter_base = &_ivi4_quant_4x4_inter[_quant_index_to_tab[band->quant_mat]][0]; + band->_intraBase = &_ivi4_quant_4x4_intra[_quant_index_to_tab[band->_quantMat]][0]; + band->_interBase = &_ivi4_quant_4x4_inter[_quant_index_to_tab[band->_quantMat]][0]; } // Indeo 4 doesn't use scale tables - band->intra_scale = NULL; - band->inter_scale = NULL; + band->_intraScale = NULL; + band->_interScale = NULL; - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); - if (!band->scan) { - warning("band->scan not set"); + if (!band->_scan) { + warning("band->_scan not set"); return -1; } @@ -446,155 +446,154 @@ int Indeo4Decoder::decode_band_hdr(IVIBandDesc *band) { } int Indeo4Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { - int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb, + 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->mb_size * band->pitch; + int row_offset = band->_mbSize * band->_pitch; - mb = tile->mbs; - ref_mb = tile->ref_mbs; - offs = tile->ypos * band->pitch + tile->xpos; + mb = tile->_mbs; + ref_mb = tile->_refMbs; + offs = tile->_yPos * band->_pitch + tile->_xPos; - blks_per_mb = band->mb_size != band->blk_size ? 4 : 1; - mb_type_bits = _ctx.frame_type == IVI4_FRAMETYPE_BIDIR ? 2 : 1; + blks_per_mb = band->_mbSize != band->_blkSize ? 4 : 1; + mb_type_bits = _ctx._frameType == IVI4_FRAMETYPE_BIDIR ? 2 : 1; /* scale factor for motion vectors */ - mv_scale = (_ctx.planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3); - mv_x = mv_y = 0; + mv_scale = (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3); + _mvX = _mvY = 0; - if (((tile->width + band->mb_size - 1) / band->mb_size) * ((tile->height + band->mb_size - 1) / band->mb_size) != tile->num_MBs) { - warning("num_MBs mismatch %d %d %d %d", tile->width, tile->height, band->mb_size, tile->num_MBs); + 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); return -1; } - for (y = tile->ypos; y < tile->ypos + tile->height; y += band->mb_size) { + for (y = tile->_yPos; y < tile->_yPos + tile->_height; y += band->_mbSize) { mb_offset = offs; - for (x = tile->xpos; x < tile->xpos + tile->width; x += band->mb_size) { - mb->xpos = x; - mb->ypos = y; - mb->buf_offs = mb_offset; - mb->b_mv_x = - mb->b_mv_y = 0; + for (x = tile->_xPos; x < tile->_xPos + tile->_width; x += band->_mbSize) { + mb->_xPos = x; + mb->_yPos = y; + mb->_bufOffs = mb_offset; + mb->_bMvX = mb->_bMvY = 0; - if (_ctx.gb->getBits1()) { - if (_ctx.frame_type == IVI4_FRAMETYPE_INTRA) { + if (_ctx._gb->getBits1()) { + if (_ctx._frameType == IVI4_FRAMETYPE_INTRA) { warning("Empty macroblock in an INTRA picture!"); return -1; } - mb->type = 1; // empty macroblocks are always INTER - mb->cbp = 0; // all blocks are empty + mb->_type = 1; // empty macroblocks are always INTER + mb->_cbp = 0; // all blocks are empty - mb->q_delta = 0; - if (!band->plane && !band->band_num && _ctx.in_q) { - mb->q_delta = _ctx.gb->getVLC2(_ctx.mb_vlc.tab->_table, + mb->_qDelta = 0; + if (!band->_plane && !band->_bandNum && _ctx._inQ) { + mb->_qDelta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - mb->q_delta = IVI_TOSIGNED(mb->q_delta); + mb->_qDelta = IVI_TOSIGNED(mb->_qDelta); } - mb->mv_x = mb->mv_y = 0; /* no motion vector coded */ - if (band->inherit_mv && ref_mb) { - /* motion vector inheritance */ + mb->_mvX = mb->_mvY = 0; // no motion vector coded + if (band->_inheritMv && ref_mb) { + // motion vector inheritance if (mv_scale) { - mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); - mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale); + mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); + mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); } else { - mb->mv_x = ref_mb->mv_x; - mb->mv_y = ref_mb->mv_y; + mb->_mvX = ref_mb->_mvX; + mb->_mvY = ref_mb->_mvY; } } } else { - if (band->inherit_mv) { + if (band->_inheritMv) { // copy mb_type from corresponding reference mb if (!ref_mb) { warning("ref_mb unavailable"); return -1; } - mb->type = ref_mb->type; - } else if (_ctx.frame_type == IVI4_FRAMETYPE_INTRA || - _ctx.frame_type == IVI4_FRAMETYPE_INTRA1) { - mb->type = 0; // mb_type is always INTRA for intra-frames + mb->_type = ref_mb->_type; + } else if (_ctx._frameType == IVI4_FRAMETYPE_INTRA || + _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(mb_type_bits); } - mb->cbp = _ctx.gb->getBits(blks_per_mb); + mb->_cbp = _ctx._gb->getBits(blks_per_mb); - mb->q_delta = 0; - if (band->inherit_qdelta) { - if (ref_mb) mb->q_delta = ref_mb->q_delta; - } else if (mb->cbp || (!band->plane && !band->band_num && - _ctx.in_q)) { - mb->q_delta = _ctx.gb->getVLC2(_ctx.mb_vlc.tab->_table, + mb->_qDelta = 0; + if (band->_inheritQDelta) { + if (ref_mb) mb->_qDelta = ref_mb->_qDelta; + } else if (mb->_cbp || (!band->_plane && !band->_bandNum && + _ctx._inQ)) { + mb->_qDelta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - mb->q_delta = IVI_TOSIGNED(mb->q_delta); + mb->_qDelta = IVI_TOSIGNED(mb->_qDelta); } - if (!mb->type) { - mb->mv_x = mb->mv_y = 0; // there is no motion vector in intra-macroblocks + if (!mb->_type) { + mb->_mvX = mb->_mvY = 0; // there is no motion vector in intra-macroblocks } else { - if (band->inherit_mv) { + if (band->_inheritMv) { if (ref_mb) { // motion vector inheritance if (mv_scale) { - mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); - mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale); + mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); + mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); } else { - mb->mv_x = ref_mb->mv_x; - mb->mv_y = ref_mb->mv_y; + mb->_mvX = ref_mb->_mvX; + mb->_mvY = ref_mb->_mvY; } } } else { // decode motion vector deltas - mv_delta = _ctx.gb->getVLC2(_ctx.mb_vlc.tab->_table, + mv_delta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - mv_y += IVI_TOSIGNED(mv_delta); - mv_delta = _ctx.gb->getVLC2(_ctx.mb_vlc.tab->_table, + _mvY += IVI_TOSIGNED(mv_delta); + mv_delta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - mv_x += IVI_TOSIGNED(mv_delta); - mb->mv_x = mv_x; - mb->mv_y = mv_y; - if (mb->type == 3) { - mv_delta = _ctx.gb->getVLC2( - _ctx.mb_vlc.tab->_table, + _mvX += IVI_TOSIGNED(mv_delta); + mb->_mvX = _mvX; + mb->_mvY = _mvY; + if (mb->_type == 3) { + mv_delta = _ctx._gb->getVLC2( + _ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - mv_y += IVI_TOSIGNED(mv_delta); - mv_delta = _ctx.gb->getVLC2( - _ctx.mb_vlc.tab->_table, + _mvY += IVI_TOSIGNED(mv_delta); + mv_delta = _ctx._gb->getVLC2( + _ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); - mv_x += IVI_TOSIGNED(mv_delta); - mb->b_mv_x = -mv_x; - mb->b_mv_y = -mv_y; + _mvX += IVI_TOSIGNED(mv_delta); + mb->_bMvX = -_mvX; + mb->_bMvY = -_mvY; } } - if (mb->type == 2) { - mb->b_mv_x = -mb->mv_x; - mb->b_mv_y = -mb->mv_y; - mb->mv_x = 0; - mb->mv_y = 0; + if (mb->_type == 2) { + mb->_bMvX = -mb->_mvX; + mb->_bMvY = -mb->_mvY; + mb->_mvX = 0; + mb->_mvY = 0; } } } - s = band->is_halfpel; - if (mb->type) - if (x + (mb->mv_x >> s) + (y + (mb->mv_y >> s))*band->pitch < 0 || - x + ((mb->mv_x + s) >> s) + band->mb_size - 1 - + (y + band->mb_size - 1 + ((mb->mv_y + s) >> s))*band->pitch > band->bufsize - 1) { - warning("motion vector %d %d outside reference", x*s + mb->mv_x, y*s + mb->mv_y); + s = band->_isHalfpel; + if (mb->_type) + if (x + (mb->_mvX >> s) + (y + (mb->_mvY >> s))*band->_pitch < 0 || + x + ((mb->_mvX + s) >> s) + band->_mbSize - 1 + + (y + band->_mbSize - 1 + ((mb->_mvY + s) >> s))*band->_pitch > band->_bufSize - 1) { + warning("motion vector %d %d outside reference", x*s + mb->_mvX, y*s + mb->_mvY); return -1; } mb++; if (ref_mb) ref_mb++; - mb_offset += band->mb_size; + mb_offset += band->_mbSize; } offs += row_offset; } - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); return 0; } @@ -605,12 +604,12 @@ int Indeo4Decoder::scaleTileSize(int def_size, int size_factor) { int Indeo4Decoder::decodePlaneSubdivision() { int i; - switch (_ctx.gb->getBits(2)) { + switch (_ctx._gb->getBits(2)) { case 3: return 1; case 2: for (i = 0; i < 4; i++) - if (_ctx.gb->getBits(2) != 3) + if (_ctx._gb->getBits(2) != 3) return 0; return 4; default: diff --git a/image/codecs/indeo4.h b/image/codecs/indeo4.h index 1034f18f0c..86e6020c43 100644 --- a/image/codecs/indeo4.h +++ b/image/codecs/indeo4.h @@ -52,9 +52,9 @@ using namespace Indeo; */ class Indeo4Decoder : public IndeoDecoderBase { struct Transform { - InvTransformPtr *inv_trans; - DCTransformPtr *dc_trans; - int is_2d_trans; + InvTransformPtr *_invTrans; + DCTransformPtr *_dcTrans; + bool _is2dTrans; }; public: Indeo4Decoder(uint16 width, uint16 height); diff --git a/image/codecs/indeo5.cpp b/image/codecs/indeo5.cpp index b2aebe98a8..5434e26cfa 100644 --- a/image/codecs/indeo5.cpp +++ b/image/codecs/indeo5.cpp @@ -52,10 +52,10 @@ enum { #define IVI5_PIC_SIZE_ESC 15 Indeo5Decoder::Indeo5Decoder(uint16 width, uint16 height) : IndeoDecoderBase(width, height) { - _ctx.is_indeo4 = true; - _ctx.ref_buf = 1; - _ctx.b_ref_buf = 3; - _ctx.p_frame = new AVFrame(); + _ctx._isIndeo4 = false; + _ctx._refBuf = 1; + _ctx._bRefBuf = 3; + _ctx._pFrame = new AVFrame(); } bool Indeo5Decoder::isIndeo5(Common::SeekableReadStream &stream) { @@ -83,21 +83,21 @@ const Graphics::Surface *Indeo5Decoder::decodeFrame(Common::SeekableReadStream & // Set up the frame data buffer byte *frameData = new byte[stream.size()]; stream.read(frameData, stream.size()); - _ctx.frame_data = frameData; - _ctx.frame_size = stream.size(); + _ctx._frameData = frameData; + _ctx._frameSize = stream.size(); // Set up the GetBits instance for reading the data - _ctx.gb = new GetBits(_ctx.frame_data, _ctx.frame_size * 8); + _ctx._gb = new GetBits(_ctx._frameData, _ctx._frameSize * 8); // Decode the frame int err = decodeIndeoFrame(); // Free the bit reader and frame buffer - delete _ctx.gb; - _ctx.gb = nullptr; + delete _ctx._gb; + _ctx._gb = nullptr; delete[] frameData; - _ctx.frame_data = nullptr; - _ctx.frame_size = 0; + _ctx._frameData = nullptr; + _ctx._frameSize = 0; return (err < 0) ? nullptr : &_surface->rawSurface(); } @@ -108,87 +108,87 @@ int Indeo5Decoder::decodePictureHeader() { int ret; - if (_ctx.gb->getBits(5) != 0x1F) { + if (_ctx._gb->getBits(5) != 0x1F) { warning("Invalid picture start code!"); return -1; } - _ctx.prev_frame_type = _ctx.frame_type; - _ctx.frame_type = _ctx.gb->getBits(3); - if (_ctx.frame_type >= 5) { - warning("Invalid frame type: %d", _ctx.frame_type); + _ctx._prevFrameType = _ctx._frameType; + _ctx._frameType = _ctx._gb->getBits(3); + if (_ctx._frameType >= 5) { + warning("Invalid frame type: %d", _ctx._frameType); return -1; } - _ctx.frame_num = _ctx.gb->getBits(8); + _ctx._frameNum = _ctx._gb->getBits(8); - if (_ctx.frame_type == FRAMETYPE_INTRA) { + if (_ctx._frameType == FRAMETYPE_INTRA) { if ((ret = decode_gop_header()) < 0) { warning("Invalid GOP header, skipping frames."); - _ctx.gop_invalid = 1; + _ctx._gopInvalid = true; return ret; } - _ctx.gop_invalid = 0; + _ctx._gopInvalid = false; } - if (_ctx.frame_type == FRAMETYPE_INTER_SCAL && !_ctx.is_scalable) { + if (_ctx._frameType == FRAMETYPE_INTER_SCAL && !_ctx._isScalable) { warning("Scalable inter frame in non scalable stream"); - _ctx.frame_type = FRAMETYPE_INTER; + _ctx._frameType = FRAMETYPE_INTER; return -1; } - if (_ctx.frame_type != FRAMETYPE_NULL) { - _ctx.frame_flags = _ctx.gb->getBits(8); + if (_ctx._frameType != FRAMETYPE_NULL) { + _ctx._frameFlags = _ctx._gb->getBits(8); - _ctx.pic_hdr_size = (_ctx.frame_flags & 1) ? _ctx.gb->getBitsLong(24) : 0; + _ctx._picHdrSize = (_ctx._frameFlags & 1) ? _ctx._gb->getBitsLong(24) : 0; - _ctx.checksum = (_ctx.frame_flags & 0x10) ? _ctx.gb->getBits(16) : 0; + _ctx._checksum = (_ctx._frameFlags & 0x10) ? _ctx._gb->getBits(16) : 0; // skip unknown extension if any - if (_ctx.frame_flags & 0x20) + if (_ctx._frameFlags & 0x20) skip_hdr_extension(); // XXX: untested // decode macroblock huffman codebook - ret = _ctx.mb_vlc.ff_ivi_dec_huff_desc(&_ctx, _ctx.frame_flags & 0x40, + ret = _ctx._mbVlc.ff_ivi_dec_huff_desc(&_ctx, _ctx._frameFlags & 0x40, IVI_MB_HUFF); if (ret < 0) return ret; - _ctx.gb->skipBits(3); // FIXME: unknown meaning! + _ctx._gb->skipBits(3); // FIXME: unknown meaning! } - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); return 0; } void Indeo5Decoder::switch_buffers() { - switch (_ctx.prev_frame_type) { + switch (_ctx._prevFrameType) { case FRAMETYPE_INTRA: case FRAMETYPE_INTER: - _ctx.buf_switch ^= 1; - _ctx.dst_buf = _ctx.buf_switch; - _ctx.ref_buf = _ctx.buf_switch ^ 1; + _ctx._bufSwitch ^= 1; + _ctx._dstBuf = _ctx._bufSwitch; + _ctx._refBuf = _ctx._bufSwitch ^ 1; break; case FRAMETYPE_INTER_SCAL: - if (!_ctx.inter_scal) { - _ctx.ref2_buf = 2; - _ctx.inter_scal = 1; + if (!_ctx._interScal) { + _ctx._ref2Buf = 2; + _ctx._interScal = 1; } - FFSWAP(int, _ctx.dst_buf, _ctx.ref2_buf); - _ctx.ref_buf = _ctx.ref2_buf; + FFSWAP(int, _ctx._dstBuf, _ctx._ref2Buf); + _ctx._refBuf = _ctx._ref2Buf; break; case FRAMETYPE_INTER_NOREF: break; } - switch (_ctx.frame_type) { + switch (_ctx._frameType) { case FRAMETYPE_INTRA: - _ctx.buf_switch = 0; + _ctx._bufSwitch = 0; // FALLTHROUGH case FRAMETYPE_INTER: - _ctx.inter_scal = 0; - _ctx.dst_buf = _ctx.buf_switch; - _ctx.ref_buf = _ctx.buf_switch ^ 1; + _ctx._interScal = 0; + _ctx._dstBuf = _ctx._bufSwitch; + _ctx._refBuf = _ctx._bufSwitch ^ 1; break; case FRAMETYPE_INTER_SCAL: case FRAMETYPE_INTER_NOREF: @@ -198,207 +198,209 @@ void Indeo5Decoder::switch_buffers() { } bool Indeo5Decoder::is_nonnull_frame() const { - return _ctx.frame_type != FRAMETYPE_NULL; + return _ctx._frameType != FRAMETYPE_NULL; } int Indeo5Decoder::decode_band_hdr(IVIBandDesc *band) { int i, ret; uint8 band_flags; - band_flags = _ctx.gb->getBits(8); + band_flags = _ctx._gb->getBits(8); if (band_flags & 1) { - band->is_empty = 1; + band->_isEmpty = true; return 0; } - band->data_size = (_ctx.frame_flags & 0x80) ? _ctx.gb->getBitsLong(24) : 0; + band->_dataSize = (_ctx._frameFlags & 0x80) ? _ctx._gb->getBitsLong(24) : 0; - band->inherit_mv = band_flags & 2; - band->inherit_qdelta = band_flags & 8; - band->qdelta_present = band_flags & 4; - if (!band->qdelta_present) band->inherit_qdelta = 1; + band->_inheritMv = (band_flags & 2) != 0; + band->_inheritQDelta = (band_flags & 8) != 0; + band->_qdeltaPresent = (band_flags & 4) != 0; + if (!band->_qdeltaPresent) + band->_inheritQDelta = 1; // decode rvmap probability corrections if any - band->num_corr = 0; // there are no corrections + band->_numCorr = 0; // there are no corrections if (band_flags & 0x10) { - band->num_corr = _ctx.gb->getBits(8); // get number of correction pairs - if (band->num_corr > 61) { - warning("Too many corrections: %d", band->num_corr); + band->_numCorr = _ctx._gb->getBits(8); // get number of correction pairs + if (band->_numCorr > 61) { + warning("Too many corrections: %d", band->_numCorr); return -1; } // read correction pairs - for (i = 0; i < band->num_corr * 2; i++) - band->corr[i] = _ctx.gb->getBits(8); + for (i = 0; i < band->_numCorr * 2; i++) + band->_corr[i] = _ctx._gb->getBits(8); } // select appropriate rvmap table for this band - band->rvmap_sel = (band_flags & 0x40) ? _ctx.gb->getBits(3) : 8; + band->_rvmapSel = (band_flags & 0x40) ? _ctx._gb->getBits(3) : 8; // decode block huffman codebook - ret = band->blk_vlc.ff_ivi_dec_huff_desc(&_ctx, band_flags & 0x80, IVI_BLK_HUFF); + ret = band->_blkVlc.ff_ivi_dec_huff_desc(&_ctx, band_flags & 0x80, IVI_BLK_HUFF); if (ret < 0) return ret; - band->checksum_present = _ctx.gb->getBits1(); - if (band->checksum_present) - band->checksum = _ctx.gb->getBits(16); + band->_checksumPresent = _ctx._gb->getBits1(); + if (band->_checksumPresent) + band->_checksum = _ctx._gb->getBits(16); - band->glob_quant = _ctx.gb->getBits(5); + band->_globQuant = _ctx._gb->getBits(5); // skip unknown extension if any if (band_flags & 0x20) { // XXX: untested - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); skip_hdr_extension(); } - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); return 0; } int Indeo5Decoder::decode_mb_info(IVIBandDesc *band, IVITile *tile) { - int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, + int x, y, _mvX, _mvY, mv_delta, offs, mb_offset, mv_scale, blks_per_mb, s; IVIMbInfo *mb, *ref_mb; - int row_offset = band->mb_size * band->pitch; + int row_offset = band->_mbSize * band->_pitch; - mb = tile->mbs; - ref_mb = tile->ref_mbs; - offs = tile->ypos * band->pitch + tile->xpos; + mb = tile->_mbs; + ref_mb = tile->_refMbs; + offs = tile->_yPos * band->_pitch + tile->_xPos; if (!ref_mb && - ((band->qdelta_present && band->inherit_qdelta) || band->inherit_mv)) + ((band->_qdeltaPresent && band->_inheritQDelta) || band->_inheritMv)) return -1; - if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size)) { + if (tile->_numMBs != IVI_MBs_PER_TILE(tile->_width, tile->_height, band->_mbSize)) { warning("Allocated tile size %d mismatches parameters %d", - tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size)); + tile->_numMBs, IVI_MBs_PER_TILE(tile->_width, tile->_height, band->_mbSize)); return -1; } // scale factor for motion vectors - mv_scale = (_ctx.planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3); - mv_x = mv_y = 0; + mv_scale = (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3); + _mvX = _mvY = 0; - for (y = tile->ypos; y < (tile->ypos + tile->height); y += band->mb_size) { + for (y = tile->_yPos; y < (tile->_yPos + tile->_height); y += band->_mbSize) { mb_offset = offs; - for (x = tile->xpos; x < (tile->xpos + tile->width); x += band->mb_size) { - mb->xpos = x; - mb->ypos = y; - mb->buf_offs = mb_offset; + for (x = tile->_xPos; x < (tile->_xPos + tile->_width); x += band->_mbSize) { + mb->_xPos = x; + mb->_yPos = y; + mb->_bufOffs = mb_offset; - if (_ctx.gb->getBits1()) { - if (_ctx.frame_type == FRAMETYPE_INTRA) { + if (_ctx._gb->getBits1()) { + if (_ctx._frameType == FRAMETYPE_INTRA) { warning("Empty macroblock in an INTRA picture!"); return -1; } - mb->type = 1; // empty macroblocks are always INTER - mb->cbp = 0; // all blocks are empty + mb->_type = 1; // empty macroblocks are always INTER + mb->_cbp = 0; // all blocks are empty - mb->q_delta = 0; - if (!band->plane && !band->band_num && (_ctx.frame_flags & 8)) { - mb->q_delta = _ctx.gb->getVLC2(_ctx.mb_vlc.tab->_table, IVI_VLC_BITS, 1); - mb->q_delta = IVI_TOSIGNED(mb->q_delta); + mb->_qDelta = 0; + if (!band->_plane && !band->_bandNum && (_ctx._frameFlags & 8)) { + mb->_qDelta = _ctx._gb->getVLC2(_ctx._mbVlc._tab->_table, IVI_VLC_BITS, 1); + mb->_qDelta = IVI_TOSIGNED(mb->_qDelta); } - mb->mv_x = mb->mv_y = 0; // no motion vector coded - if (band->inherit_mv && ref_mb) { + mb->_mvX = mb->_mvY = 0; // no motion vector coded + if (band->_inheritMv && ref_mb) { // motion vector inheritance if (mv_scale) { - mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); - mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale); + mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); + mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); } else { - mb->mv_x = ref_mb->mv_x; - mb->mv_y = ref_mb->mv_y; + mb->_mvX = ref_mb->_mvX; + mb->_mvY = ref_mb->_mvY; } } } else { - if (band->inherit_mv && ref_mb) { - mb->type = ref_mb->type; // copy mb_type from corresponding reference mb - } else if (_ctx.frame_type == FRAMETYPE_INTRA) { - mb->type = 0; // mb_type is always INTRA for intra-frames + if (band->_inheritMv && ref_mb) { + mb->_type = ref_mb->_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(); + mb->_type = _ctx._gb->getBits1(); } - blks_per_mb = band->mb_size != band->blk_size ? 4 : 1; - mb->cbp = _ctx.gb->getBits(blks_per_mb); - - mb->q_delta = 0; - if (band->qdelta_present) { - if (band->inherit_qdelta) { - if (ref_mb) mb->q_delta = ref_mb->q_delta; - } else if (mb->cbp || (!band->plane && !band->band_num && - (_ctx.frame_flags & 8))) { - mb->q_delta = _ctx.gb->getVLC2(_ctx.mb_vlc.tab->_table, IVI_VLC_BITS, 1); - mb->q_delta = IVI_TOSIGNED(mb->q_delta); + blks_per_mb = band->_mbSize != band->_blkSize ? 4 : 1; + mb->_cbp = _ctx._gb->getBits(blks_per_mb); + + mb->_qDelta = 0; + if (band->_qdeltaPresent) { + if (band->_inheritQDelta) { + if (ref_mb) mb->_qDelta = ref_mb->_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); + mb->_qDelta = IVI_TOSIGNED(mb->_qDelta); } } - if (!mb->type) { - mb->mv_x = mb->mv_y = 0; // there is no motion vector in intra-macroblocks + if (!mb->_type) { + mb->_mvX = mb->_mvY = 0; // there is no motion vector in intra-macroblocks } else { - if (band->inherit_mv && ref_mb) { + if (band->_inheritMv && ref_mb) { // motion vector inheritance if (mv_scale) { - mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale); - mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale); + mb->_mvX = ivi_scale_mv(ref_mb->_mvX, mv_scale); + mb->_mvY = ivi_scale_mv(ref_mb->_mvY, mv_scale); } else { - mb->mv_x = ref_mb->mv_x; - mb->mv_y = ref_mb->mv_y; + mb->_mvX = ref_mb->_mvX; + mb->_mvY = ref_mb->_mvY; } } else { // decode motion vector deltas - mv_delta = _ctx.gb->getVLC2(_ctx.mb_vlc.tab->_table, IVI_VLC_BITS, 1); - mv_y += IVI_TOSIGNED(mv_delta); - mv_delta = _ctx.gb->getVLC2(_ctx.mb_vlc.tab->_table, IVI_VLC_BITS, 1); - mv_x += IVI_TOSIGNED(mv_delta); - mb->mv_x = mv_x; - mb->mv_y = mv_y; + 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; } } } - s = band->is_halfpel; - if (mb->type) - if (x + (mb->mv_x >> s) + (y + (mb->mv_y >> s))*band->pitch < 0 || - x + ((mb->mv_x + s) >> s) + band->mb_size - 1 - + (y + band->mb_size - 1 + ((mb->mv_y + s) >> s))*band->pitch > band->bufsize - 1) { - warning("motion vector %d %d outside reference", x*s + mb->mv_x, y*s + mb->mv_y); + s = band->_isHalfpel; + if (mb->_type) + if (x + (mb->_mvX >> s) + (y + (mb->_mvY >> s))*band->_pitch < 0 || + x + ((mb->_mvX + s) >> s) + band->_mbSize - 1 + + (y + band->_mbSize - 1 + ((mb->_mvY + s) >> s))*band->_pitch > band->_bufSize - 1) { + warning("motion vector %d %d outside reference", x*s + mb->_mvX, y*s + mb->_mvY); return -1; } mb++; if (ref_mb) ref_mb++; - mb_offset += band->mb_size; + mb_offset += band->_mbSize; } offs += row_offset; } - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); return 0; } int Indeo5Decoder::decode_gop_header() { - int result, i, p, tile_size, pic_size_indx, mb_size, blk_size, is_scalable; - int quant_mat, blk_size_changed = 0; + int result, i, p, tile_size, pic_size_indx, mbSize, blkSize, isScalable; + int quantMat; + bool blk_size_changed = false; IVIBandDesc *band, *band1, *band2; IVIPicConfig pic_conf; - _ctx.gop_flags = _ctx.gb->getBits(8); + _ctx._gopFlags = _ctx._gb->getBits(8); - _ctx.gop_hdr_size = (_ctx.gop_flags & 1) ? _ctx.gb->getBits(16) : 0; + _ctx._gopHdrSize = (_ctx._gopFlags & 1) ? _ctx._gb->getBits(16) : 0; - if (_ctx.gop_flags & IVI5_IS_PROTECTED) - _ctx.lock_word = _ctx.gb->getBitsLong(32); + if (_ctx._gopFlags & IVI5_IS_PROTECTED) + _ctx._lockWord = _ctx._gb->getBitsLong(32); - tile_size = (_ctx.gop_flags & 0x40) ? 64 << _ctx.gb->getBits(2) : 0; + tile_size = (_ctx._gopFlags & 0x40) ? 64 << _ctx._gb->getBits(2) : 0; if (tile_size > 256) { warning("Invalid tile size: %d", tile_size); return -1; @@ -406,73 +408,73 @@ int Indeo5Decoder::decode_gop_header() { // decode number of wavelet bands // num_levels * 3 + 1 - pic_conf.luma_bands = _ctx.gb->getBits(2) * 3 + 1; - pic_conf.chroma_bands = _ctx.gb->getBits1() * 3 + 1; - is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1; - if (is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 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)) { warning("Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d", - pic_conf.luma_bands, pic_conf.chroma_bands); + pic_conf._lumaBands, pic_conf._chromaBands); return -1; } - pic_size_indx = _ctx.gb->getBits(4); + pic_size_indx = _ctx._gb->getBits(4); if (pic_size_indx == IVI5_PIC_SIZE_ESC) { - pic_conf.pic_height = _ctx.gb->getBits(13); - pic_conf.pic_width = _ctx.gb->getBits(13); + pic_conf._picHeight = _ctx._gb->getBits(13); + pic_conf._picWidth = _ctx._gb->getBits(13); } else { - pic_conf.pic_height = _ivi5_common_pic_sizes[pic_size_indx * 2 + 1] << 2; - pic_conf.pic_width = _ivi5_common_pic_sizes[pic_size_indx * 2] << 2; + 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; } - if (_ctx.gop_flags & 2) { + if (_ctx._gopFlags & 2) { warning("YV12 picture format"); return -2; } - pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2; - pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2; + pic_conf._chromaHeight = (pic_conf._picHeight + 3) >> 2; + pic_conf._chromaWidth = (pic_conf._picWidth + 3) >> 2; if (!tile_size) { - pic_conf.tile_height = pic_conf.pic_height; - pic_conf.tile_width = pic_conf.pic_width; + pic_conf._tileHeight = pic_conf._picHeight; + pic_conf._tileWidth = pic_conf._picWidth; } else { - pic_conf.tile_height = pic_conf.tile_width = tile_size; + pic_conf._tileHeight = pic_conf._tileWidth = tile_size; } // check if picture layout was changed and reallocate buffers - if (pic_conf.ivi_pic_config_cmp(_ctx.pic_conf) || _ctx.gop_invalid) { - result = IVIPlaneDesc::ff_ivi_init_planes(_ctx.planes, &pic_conf, 0); + if (pic_conf.ivi_pic_config_cmp(_ctx._picConf) || _ctx._gopInvalid) { + result = IVIPlaneDesc::ff_ivi_init_planes(_ctx._planes, &pic_conf, 0); if (result < 0) { warning("Couldn't reallocate color planes!"); return result; } - _ctx.pic_conf = pic_conf; - _ctx.is_scalable = is_scalable; + _ctx._picConf = pic_conf; + _ctx._isScalable = isScalable; blk_size_changed = 1; // force reallocation of the internal structures } for (p = 0; p <= 1; p++) { - for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) { - band = &_ctx.planes[p].bands[i]; + for (i = 0; i < (!p ? pic_conf._lumaBands : pic_conf._chromaBands); i++) { + band = &_ctx._planes[p]._bands[i]; - band->is_halfpel = _ctx.gb->getBits1(); + band->_isHalfpel = _ctx._gb->getBits1(); - mb_size = _ctx.gb->getBits1(); - blk_size = 8 >> _ctx.gb->getBits1(); - mb_size = blk_size << !mb_size; + mbSize = _ctx._gb->getBits1(); + blkSize = 8 >> _ctx._gb->getBits1(); + mbSize = blkSize << !mbSize; - if (p == 0 && blk_size == 4) { + if (p == 0 && blkSize == 4) { warning("4x4 luma blocks are unsupported!"); return -2; } - blk_size_changed = mb_size != band->mb_size || blk_size != band->blk_size; + blk_size_changed = mbSize != band->_mbSize || blkSize != band->_blkSize; if (blk_size_changed) { - band->mb_size = mb_size; - band->blk_size = blk_size; + band->_mbSize = mbSize; + band->_blkSize = blkSize; } - if (_ctx.gb->getBits1()) { + if (_ctx._gb->getBits1()) { warning("Extended transform info"); return -2; } @@ -480,73 +482,73 @@ int Indeo5Decoder::decode_gop_header() { // select transform function and scan pattern according to plane and band number switch ((p << 2) + i) { case 0: - band->inv_transform = IndeoDSP::ff_ivi_inverse_slant_8x8; - band->dc_transform = IndeoDSP::ff_ivi_dc_slant_2d; - band->scan = ff_zigzag_direct; - band->transform_size = 8; + band->_invTransform = IndeoDSP::ff_ivi_inverse_slant_8x8; + band->_dcTransform = IndeoDSP::ff_ivi_dc_slant_2d; + band->_scan = ff_zigzag_direct; + band->_transformSize = 8; break; case 1: - band->inv_transform = IndeoDSP::ff_ivi_row_slant8; - band->dc_transform = IndeoDSP::ff_ivi_dc_row_slant; - band->scan = _ff_ivi_vertical_scan_8x8; - band->transform_size = 8; + band->_invTransform = IndeoDSP::ff_ivi_row_slant8; + band->_dcTransform = IndeoDSP::ff_ivi_dc_row_slant; + band->_scan = _ff_ivi_vertical_scan_8x8; + band->_transformSize = 8; break; case 2: - band->inv_transform = IndeoDSP::ff_ivi_col_slant8; - band->dc_transform = IndeoDSP::ff_ivi_dc_col_slant; - band->scan = _ff_ivi_horizontal_scan_8x8; - band->transform_size = 8; + band->_invTransform = IndeoDSP::ff_ivi_col_slant8; + band->_dcTransform = IndeoDSP::ff_ivi_dc_col_slant; + band->_scan = _ff_ivi_horizontal_scan_8x8; + band->_transformSize = 8; break; case 3: - band->inv_transform = IndeoDSP::ff_ivi_put_pixels_8x8; - band->dc_transform = IndeoDSP::ff_ivi_put_dc_pixel_8x8; - band->scan = _ff_ivi_horizontal_scan_8x8; - band->transform_size = 8; + band->_invTransform = IndeoDSP::ff_ivi_put_pixels_8x8; + band->_dcTransform = IndeoDSP::ff_ivi_put_dc_pixel_8x8; + band->_scan = _ff_ivi_horizontal_scan_8x8; + band->_transformSize = 8; break; case 4: - band->inv_transform = IndeoDSP::ff_ivi_inverse_slant_4x4; - band->dc_transform = IndeoDSP::ff_ivi_dc_slant_2d; - band->scan = _ff_ivi_direct_scan_4x4; - band->transform_size = 4; + band->_invTransform = IndeoDSP::ff_ivi_inverse_slant_4x4; + band->_dcTransform = IndeoDSP::ff_ivi_dc_slant_2d; + band->_scan = _ff_ivi_direct_scan_4x4; + band->_transformSize = 4; break; } - band->is_2d_trans = band->inv_transform == IndeoDSP::ff_ivi_inverse_slant_8x8 || - band->inv_transform == IndeoDSP::ff_ivi_inverse_slant_4x4; + band->_is2dTrans = band->_invTransform == IndeoDSP::ff_ivi_inverse_slant_8x8 || + band->_invTransform == IndeoDSP::ff_ivi_inverse_slant_4x4; - if (band->transform_size != band->blk_size) { - warning("transform and block size mismatch (%d != %d)", band->transform_size, band->blk_size); + if (band->_transformSize != band->_blkSize) { + warning("transform and block size mismatch (%d != %d)", band->_transformSize, band->_blkSize); return -1; } // select dequant matrix according to plane and band number if (!p) { - quant_mat = (pic_conf.luma_bands > 1) ? i + 1 : 0; + quantMat = (pic_conf._lumaBands > 1) ? i + 1 : 0; } else { - quant_mat = 5; + quantMat = 5; } - if (band->blk_size == 8) { - if (quant_mat >= 5) { - warning("quant_mat %d too large!", quant_mat); + if (band->_blkSize == 8) { + if (quantMat >= 5) { + warning("_quantMat %d too large!", quantMat); return -1; } - band->intra_base = &_ivi5_base_quant_8x8_intra[quant_mat][0]; - band->inter_base = &_ivi5_base_quant_8x8_inter[quant_mat][0]; - band->intra_scale = &_ivi5_scale_quant_8x8_intra[quant_mat][0]; - band->inter_scale = &_ivi5_scale_quant_8x8_inter[quant_mat][0]; + band->_intraBase = &_ivi5_base_quant_8x8_intra[quantMat][0]; + band->_interBase = &_ivi5_base_quant_8x8_inter[quantMat][0]; + band->_intraScale = &_ivi5_scale_quant_8x8_intra[quantMat][0]; + band->_interScale = &_ivi5_scale_quant_8x8_inter[quantMat][0]; } else { - band->intra_base = _ivi5_base_quant_4x4_intra; - band->inter_base = _ivi5_base_quant_4x4_inter; - band->intra_scale = _ivi5_scale_quant_4x4_intra; - band->inter_scale = _ivi5_scale_quant_4x4_inter; + band->_intraBase = _ivi5_base_quant_4x4_intra; + band->_interBase = _ivi5_base_quant_4x4_inter; + band->_intraScale = _ivi5_scale_quant_4x4_intra; + band->_interScale = _ivi5_scale_quant_4x4_inter; } - if (_ctx.gb->getBits(2)) { + if (_ctx._gb->getBits(2)) { warning("End marker missing!"); return -1; } @@ -554,58 +556,58 @@ int Indeo5Decoder::decode_gop_header() { } // copy chroma parameters into the 2nd chroma plane - for (i = 0; i < pic_conf.chroma_bands; i++) { - band1 = &_ctx.planes[1].bands[i]; - band2 = &_ctx.planes[2].bands[i]; - - band2->width = band1->width; - band2->height = band1->height; - band2->mb_size = band1->mb_size; - band2->blk_size = band1->blk_size; - band2->is_halfpel = band1->is_halfpel; - band2->intra_base = band1->intra_base; - band2->inter_base = band1->inter_base; - band2->intra_scale = band1->intra_scale; - band2->inter_scale = band1->inter_scale; - band2->scan = band1->scan; - band2->inv_transform = band1->inv_transform; - band2->dc_transform = band1->dc_transform; - band2->is_2d_trans = band1->is_2d_trans; - band2->transform_size = band1->transform_size; + for (i = 0; i < pic_conf._chromaBands; i++) { + band1 = &_ctx._planes[1]._bands[i]; + band2 = &_ctx._planes[2]._bands[i]; + + band2->_width = band1->_width; + band2->_height = band1->_height; + band2->_mbSize = band1->_mbSize; + band2->_blkSize = band1->_blkSize; + band2->_isHalfpel = band1->_isHalfpel; + band2->_intraBase = band1->_intraBase; + band2->_interBase = band1->_interBase; + band2->_intraScale = band1->_intraScale; + band2->_interScale = band1->_interScale; + band2->_scan = band1->_scan; + band2->_invTransform = band1->_invTransform; + band2->_dcTransform = band1->_dcTransform; + band2->_is2dTrans = band1->_is2dTrans; + band2->_transformSize = band1->_transformSize; } // reallocate internal structures if needed if (blk_size_changed) { - result = IVIPlaneDesc::ff_ivi_init_tiles(_ctx.planes, pic_conf.tile_width, - pic_conf.tile_height); + result = IVIPlaneDesc::ff_ivi_init_tiles(_ctx._planes, pic_conf._tileWidth, + pic_conf._tileHeight); if (result < 0) { warning("Couldn't reallocate internal structures!"); return result; } } - if (_ctx.gop_flags & 8) { - if (_ctx.gb->getBits(3)) { + if (_ctx._gopFlags & 8) { + if (_ctx._gb->getBits(3)) { warning("Alignment bits are not zero!"); return -1; } - if (_ctx.gb->getBits1()) - _ctx.gb->skipBitsLong(24); // skip transparency fill color + if (_ctx._gb->getBits1()) + _ctx._gb->skipBitsLong(24); // skip transparency fill color } - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); - _ctx.gb->skipBits(23); // FIXME: unknown meaning + _ctx._gb->skipBits(23); // FIXME: unknown meaning // skip GOP extension if any - if (_ctx.gb->getBits1()) { + if (_ctx._gb->getBits1()) { do { - i = _ctx.gb->getBits(16); + i = _ctx._gb->getBits(16); } while (i & 0x8000); } - _ctx.gb->alignGetBits(); + _ctx._gb->alignGetBits(); return 0; } @@ -614,11 +616,11 @@ int Indeo5Decoder::skip_hdr_extension() { int i, len; do { - len = _ctx.gb->getBits(8); - if (8 * len > _ctx.gb->getBitsLeft()) + len = _ctx._gb->getBits(8); + if (8 * len > _ctx._gb->getBitsLeft()) return -1; for (i = 0; i < len; i++) - _ctx.gb->skipBits(8); + _ctx._gb->skipBits(8); } while (len); return 0; |