aboutsummaryrefslogtreecommitdiff
path: root/image
diff options
context:
space:
mode:
Diffstat (limited to 'image')
-rw-r--r--image/codecs/indeo/indeo.cpp934
-rw-r--r--image/codecs/indeo/indeo.h315
-rw-r--r--image/codecs/indeo4.cpp465
-rw-r--r--image/codecs/indeo4.h6
-rw-r--r--image/codecs/indeo5.cpp482
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;