IMAGE: Cleanup of miscellaneous methods and arrays in Indeo decoders

10 files changed, 454 insertions, 469 deletions

diff --git a/image/codecs/indeo/indeo.cpp b/image/codecs/indeo/indeo.cpp
index 4f290160ed..f473b267bf 100644
--- a/image/codecs/indeo/indeo.cpp
+++ b/image/codecs/indeo/indeo.cpp
@@ -105,7 +105,7 @@ int IVIHuffDesc::createHuffFromDesc(VLC *vlc, bool flag) const {
             if (bits[pos] > IVI_VLC_BITS)
                 return -1; // invalid descriptor
 
-            codewords[pos] = inv_bits((prefix | j), bits[pos]);
+            codewords[pos] = invertBits((prefix | j), bits[pos]);
             if (!bits[pos])
                 bits[pos] = 1;
 
@@ -227,8 +227,8 @@ int IVIBandDesc::initTiles(IVITile *refTile, int p, int b, int tHeight, int tWid
 			tile->_numMBs = IVI_MBs_PER_TILE(tile->_width, tile->_height,
 				_mbSize);
 
-			av_freep(&tile->_mbs);
-			tile->_mbs = (IVIMbInfo *)av_mallocz_array(tile->_numMBs, sizeof(IVIMbInfo));
+			avFreeP(&tile->_mbs);
+			tile->_mbs = (IVIMbInfo *)avMallocZArray(tile->_numMBs, sizeof(IVIMbInfo));
 			if (!tile->_mbs)
 				return -2;
 
@@ -289,7 +289,7 @@ int IVIPlaneDesc::initPlanes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool
 	planes[1]._numBands = planes[2]._numBands = cfg->_chromaBands;
 
 	for (p = 0; p < 3; p++) {
-		planes[p]._bands = (IVIBandDesc *)av_mallocz_array(planes[p]._numBands, sizeof(IVIBandDesc));
+		planes[p]._bands = (IVIBandDesc *)avMallocZArray(planes[p]._numBands, sizeof(IVIBandDesc));
 		if (!planes[p]._bands)
 			return -2;
 
@@ -316,20 +316,20 @@ int IVIPlaneDesc::initPlanes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool
 			band->_height = b_height;
 			band->_pitch = width_aligned;
 			band->_aHeight = height_aligned;
-			band->_bufs[0] = (int16 *)av_mallocz(bufSize);
-			band->_bufs[1] = (int16 *)av_mallocz(bufSize);
+			band->_bufs[0] = (int16 *)avMallocZ(bufSize);
+			band->_bufs[1] = (int16 *)avMallocZ(bufSize);
 			band->_bufSize = bufSize / 2;
 			if (!band->_bufs[0] || !band->_bufs[1])
 				return -2;
 
 			// allocate the 3rd band buffer for scalability mode
 			if (cfg->_lumaBands > 1) {
-				band->_bufs[2] = (int16 *)av_mallocz(bufSize);
+				band->_bufs[2] = (int16 *)avMallocZ(bufSize);
 				if (!band->_bufs[2])
 					return -2;
 			}
 			if (isIndeo4) {
-				band->_bufs[3] = (int16 *)av_mallocz(bufSize);
+				band->_bufs[3] = (int16 *)avMallocZ(bufSize);
 				if (!band->_bufs[3])
 					return -2;
 			}
@@ -362,8 +362,8 @@ int IVIPlaneDesc::initTiles(IVIPlaneDesc *planes, int tileWidth, int tileHeight)
 			yTiles = IVI_NUM_TILES(band->_height, tHeight);
 			band->_numTiles = xTiles * yTiles;
 
-			av_freep(&band->_tiles);
-			band->_tiles = (IVITile *)av_mallocz_array(band->_numTiles, sizeof(IVITile));
+			avFreeP(&band->_tiles);
+			band->_tiles = (IVITile *)avMallocZArray(band->_numTiles, sizeof(IVITile));
 			if (!band->_tiles)
 				return -2;
 
@@ -385,18 +385,18 @@ void IVIPlaneDesc::freeBuffers(IVIPlaneDesc *planes) {
 	for (p = 0; p < 3; p++) {
 		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]);
+				avFreeP(&planes[p]._bands[b]._bufs[0]);
+				avFreeP(&planes[p]._bands[b]._bufs[1]);
+				avFreeP(&planes[p]._bands[b]._bufs[2]);
+				avFreeP(&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);
+					avFreeP(&planes[p]._bands[b]._tiles[t]._mbs);
+				avFreeP(&planes[p]._bands[b]._tiles);
 			}
-		av_freep(&planes[p]._bands);
+		avFreeP(&planes[p]._bands);
 		planes[p]._numBands = 0;
 	}
 }
@@ -427,11 +427,11 @@ int AVFrame::getBuffer(int flags) {
 	freeFrame();
 
 	// Luminance channel
-	_data[0] = (uint8 *)av_mallocz(_width * _height);
+	_data[0] = (uint8 *)avMallocZ(_width * _height);
 	
 	// UV Chroma Channels
-	_data[1] = (uint8 *)av_malloc(_width * _height);
-	_data[2] = (uint8 *)av_malloc(_width * _height);
+	_data[1] = (uint8 *)avMalloc(_width * _height);
+	_data[2] = (uint8 *)avMalloc(_width * _height);
 	Common::fill(_data[1], _data[1] + _width * _height, 0x80);
 	Common::fill(_data[2], _data[2] + _width * _height, 0x80);
 
@@ -439,9 +439,9 @@ int AVFrame::getBuffer(int flags) {
 }
 
 void AVFrame::freeFrame() {
-	av_freep(&_data[0]);
-	av_freep(&_data[1]);
-	av_freep(&_data[2]);
+	avFreeP(&_data[0]);
+	avFreeP(&_data[1]);
+	avFreeP(&_data[2]);
 }
 
 /*------------------------------------------------------------------------*/
@@ -739,10 +739,10 @@ void IndeoDecoderBase::recomposeHaar(const IVIPlaneDesc *_plane,
 			p3 = (b0 - b1 - b2 + b3 + 2) >> 2;
 
 			// bias, convert and output four pixels
-			dst[x] = av_clip_uint8(p0 + 128);
-			dst[x + 1] = av_clip_uint8(p1 + 128);
-			dst[dstPitch + x] = av_clip_uint8(p2 + 128);
-			dst[dstPitch + x + 1] = av_clip_uint8(p3 + 128);
+			dst[x] = avClipUint8(p0 + 128);
+			dst[x + 1] = avClipUint8(p1 + 128);
+			dst[dstPitch + x] = avClipUint8(p2 + 128);
+			dst[dstPitch + x + 1] = avClipUint8(p3 + 128);
 		}// for x
 
 		dst += dstPitch << 1;
@@ -893,10 +893,10 @@ void IndeoDecoderBase::recompose53(const IVIPlaneDesc *_plane,
 			}
 
 			// output four pixels
-			dst[x] = av_clip_uint8((p0 >> 6) + 128);
-			dst[x + 1] = av_clip_uint8((p1 >> 6) + 128);
-			dst[dstPitch + x] = av_clip_uint8((p2 >> 6) + 128);
-			dst[dstPitch + x + 1] = av_clip_uint8((p3 >> 6) + 128);
+			dst[x] = avClipUint8((p0 >> 6) + 128);
+			dst[x + 1] = avClipUint8((p1 >> 6) + 128);
+			dst[dstPitch + x] = avClipUint8((p2 >> 6) + 128);
+			dst[dstPitch + x + 1] = avClipUint8((p3 >> 6) + 128);
 		}// for x
 
 		dst += dstPitch << 1;
@@ -920,7 +920,7 @@ void IndeoDecoderBase::outputPlane(IVIPlaneDesc *_plane, uint8 *dst, int dstPitc
 
 	for (y = 0; y < _plane->_height; y++) {
 		for (x = 0; x < _plane->_width; x++)
-			dst[x] = av_clip_uint8(src[x] + 128);
+			dst[x] = avClipUint8(src[x] + 128);
 		src += pitch;
 		dst += dstPitch;
 	}
@@ -1006,8 +1006,8 @@ int IndeoDecoderBase::processEmptyTile(IVIBandDesc *band,
 
 	if (band->_inheritMv && needMc) { // apply motion compensation if there is at least one non-zero motion vector
 		numBlocks = (band->_mbSize != band->_blkSize) ? 4 : 1; // number of blocks per mb
-		mcNoDeltaFunc = (band->_blkSize == 8) ? IndeoDSP::ff_ivi_mc_8x8_no_delta
-			: IndeoDSP::ff_ivi_mc_4x4_no_delta;
+		mcNoDeltaFunc = (band->_blkSize == 8) ? IndeoDSP::ffIviMc8x8NoDelta
+			: IndeoDSP::ffIviMc4x4NoDelta;
 
 		for (mbn = 0, mb = tile->_mbs; mbn < tile->_numMBs; mb++, mbn++) {
 			mvX = mb->_mvX;
@@ -1075,15 +1075,15 @@ int IndeoDecoderBase::decodeBlocks(GetBits *_gb, IVIBandDesc *band, IVITile *til
     // number of blocks per mb
     numBlocks = (band->_mbSize != blkSize) ? 4 : 1;
     if (blkSize == 8) {
-        mcWithDeltaFunc     = IndeoDSP::ff_ivi_mc_8x8_delta;
-        mcNoDeltaFunc       = IndeoDSP::ff_ivi_mc_8x8_no_delta;
-        mcAvgWithDeltaFunc = IndeoDSP::ff_ivi_mc_avg_8x8_delta;
-        mcAvgNoDeltaFunc   = IndeoDSP::ff_ivi_mc_avg_8x8_no_delta;
+        mcWithDeltaFunc     = IndeoDSP::ffIviMc8x8Delta;
+        mcNoDeltaFunc       = IndeoDSP::ffIviMc8x8NoDelta;
+        mcAvgWithDeltaFunc = IndeoDSP::ffIviMcAvg8x8Delta;
+        mcAvgNoDeltaFunc   = IndeoDSP::ffIviMcAvg8x8NoDelta;
     } else {
-        mcWithDeltaFunc     = IndeoDSP::ff_ivi_mc_4x4_delta;
-        mcNoDeltaFunc       = IndeoDSP::ff_ivi_mc_4x4_no_delta;
-        mcAvgWithDeltaFunc = IndeoDSP::ff_ivi_mc_avg_4x4_delta;
-        mcAvgNoDeltaFunc   = IndeoDSP::ff_ivi_mc_avg_4x4_no_delta;
+        mcWithDeltaFunc     = IndeoDSP::ffIviMc4x4Delta;
+        mcNoDeltaFunc       = IndeoDSP::ffIviMc4x4NoDelta;
+        mcAvgWithDeltaFunc = IndeoDSP::ffIviMcAvg4x4Delta;
+        mcAvgNoDeltaFunc   = IndeoDSP::ffIviMcAvg4x4NoDelta;
     }
 
     for (mbn = 0, mb = tile->_mbs; mbn < tile->_numMBs; mb++, mbn++) {
@@ -1093,7 +1093,7 @@ int IndeoDecoderBase::decodeBlocks(GetBits *_gb, IVIBandDesc *band, IVITile *til
 
         quant = band->_globQuant + mb->_qDelta;
         if (_ctx._isIndeo4)
-            quant = av_clip_uintp2(quant, 5);
+            quant = avClipUintp2(quant, 5);
         else
             quant = av_clip((int)quant, 0, 23);
 
@@ -1346,7 +1346,7 @@ int IndeoDecoderBase::ivi_dc_transform(IVIBandDesc *band, int *prevDc,
 
 /*------------------------------------------------------------------------*/
 
-const uint8 IndeoDecoderBase::_ff_ivi_vertical_scan_8x8[64] = {
+const uint8 IndeoDecoderBase::_ffIviVerticalScan8x8[64] = {
 	0,  8, 16, 24, 32, 40, 48, 56,
 	1,  9, 17, 25, 33, 41, 49, 57,
 	2, 10, 18, 26, 34, 42, 50, 58,
@@ -1357,7 +1357,7 @@ const uint8 IndeoDecoderBase::_ff_ivi_vertical_scan_8x8[64] = {
 	7, 15, 23, 31, 39, 47, 55, 63
 };
 
-const uint8 IndeoDecoderBase::_ff_ivi_horizontal_scan_8x8[64] = {
+const uint8 IndeoDecoderBase::_ffIviHorizontalScan8x8[64] = {
 	0,  1,  2,  3,  4,  5,  6,  7,
 	8,  9, 10, 11, 12, 13, 14, 15,
 	16, 17, 18, 19, 20, 21, 22, 23,
@@ -1368,7 +1368,7 @@ const uint8 IndeoDecoderBase::_ff_ivi_horizontal_scan_8x8[64] = {
 	56, 57, 58, 59, 60, 61, 62, 63
 };
 
-const uint8 IndeoDecoderBase::_ff_ivi_direct_scan_4x4[16] = {
+const uint8 IndeoDecoderBase::_ffIviDirectScan4x4[16] = {
 	0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
 };
 
diff --git a/image/codecs/indeo/indeo.h b/image/codecs/indeo/indeo.h
index 5f6d67f34f..2c1ed957e2 100644
--- a/image/codecs/indeo/indeo.h
+++ b/image/codecs/indeo/indeo.h
@@ -523,9 +523,9 @@ protected:
 	/**
 	 *  Scan patterns shared between indeo4 and indeo5
 	 */
-	static const uint8 _ff_ivi_vertical_scan_8x8[64];
-	static const uint8 _ff_ivi_horizontal_scan_8x8[64];
-	static const uint8 _ff_ivi_direct_scan_4x4[16];
+	static const uint8 _ffIviVerticalScan8x8[64];
+	static const uint8 _ffIviHorizontalScan8x8[64];
+	static const uint8 _ffIviDirectScan4x4[16];
 protected:
 	/**
 	 * Returns the pixel format for the decoder's surface
diff --git a/image/codecs/indeo/indeo_dsp.cpp b/image/codecs/indeo/indeo_dsp.cpp
index f13ce91502..d4803b8b93 100644
--- a/image/codecs/indeo/indeo_dsp.cpp
+++ b/image/codecs/indeo/indeo_dsp.cpp
@@ -71,13 +71,13 @@ namespace Indeo {
     d3 = COMPENSATE(t2);\
     d4 = COMPENSATE(t3); }
 
-void IndeoDSP::ff_ivi_inverse_haar_8x8(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviInverseHaar8x8(const int32 *in, int16 *out, uint32 pitch,
                              const uint8 *flags) {
-    int     i, shift, sp1, sp2, sp3, sp4;
+    int			i, shift, sp1, sp2, sp3, sp4;
     const int32 *src;
-    int32 *dst;
-    int     tmp[64];
-    int     t0, t1, t2, t3, t4, t5, t6, t7, t8;
+    int32 *		dst;
+    int			tmp[64];
+    int			t0, t1, t2, t3, t4, t5, t6, t7, t8;
 
     // apply the InvHaar8 to all columns
 #define COMPENSATE(x) (x)
@@ -126,10 +126,10 @@ void IndeoDSP::ff_ivi_inverse_haar_8x8(const int32 *in, int16 *out, uint32 pitch
 #undef  COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_row_haar8(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviRowHaar8(const int32 *in, int16 *out, uint32 pitch,
                       const uint8 *flags) {
-    int     i;
-    int     t0, t1, t2, t3, t4, t5, t6, t7, t8;
+    int		i;
+    int		t0, t1, t2, t3, t4, t5, t6, t7, t8;
 
     // apply the InvHaar8 to all rows
 #define COMPENSATE(x) (x)
@@ -150,10 +150,10 @@ void IndeoDSP::ff_ivi_row_haar8(const int32 *in, int16 *out, uint32 pitch,
 #undef  COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_col_haar8(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviColHaar8(const int32 *in, int16 *out, uint32 pitch,
                       const uint8 *flags) {
-    int     i;
-    int     t0, t1, t2, t3, t4, t5, t6, t7, t8;
+    int		i;
+    int		t0, t1, t2, t3, t4, t5, t6, t7, t8;
 
     // apply the InvHaar8 to all columns
 #define COMPENSATE(x) (x)
@@ -179,13 +179,13 @@ void IndeoDSP::ff_ivi_col_haar8(const int32 *in, int16 *out, uint32 pitch,
 #undef  COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_inverse_haar_4x4(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviInverseHaar4x4(const int32 *in, int16 *out, uint32 pitch,
                              const uint8 *flags) {
-    int     i, shift, sp1, sp2;
+    int		i, shift, sp1, sp2;
     const int32 *src;
-    int32 *dst;
-    int     tmp[16];
-    int     t0, t1, t2, t3, t4;
+    int32 *	dst;
+    int		tmp[16];
+    int		t0, t1, t2, t3, t4;
 
     // apply the InvHaar4 to all columns
 #define COMPENSATE(x) (x)
@@ -226,10 +226,10 @@ void IndeoDSP::ff_ivi_inverse_haar_4x4(const int32 *in, int16 *out, uint32 pitch
 #undef  COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_row_haar4(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviRowHaar4(const int32 *in, int16 *out, uint32 pitch,
                       const uint8 *flags) {
-    int     i;
-    int     t0, t1, t2, t3, t4;
+    int		i;
+    int		t0, t1, t2, t3, t4;
 
     // apply the InvHaar4 to all rows
 #define COMPENSATE(x) (x)
@@ -247,10 +247,10 @@ void IndeoDSP::ff_ivi_row_haar4(const int32 *in, int16 *out, uint32 pitch,
 #undef  COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_col_haar4(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviColHaar4(const int32 *in, int16 *out, uint32 pitch,
                       const uint8 *flags) {
-    int     i;
-    int     t0, t1, t2, t3, t4;
+    int		i;
+    int		t0, t1, t2, t3, t4;
 
     // apply the InvHaar8 to all columns
 #define COMPENSATE(x) (x)
@@ -271,16 +271,16 @@ void IndeoDSP::ff_ivi_col_haar4(const int32 *in, int16 *out, uint32 pitch,
 #undef  COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_dc_haar_2d(const int32 *in, int16 *out, uint32 pitch,
-                       int blk_size) {
-    int     x, y;
-    int16 dc_coeff;
+void IndeoDSP::ffIviDcHaar2d(const int32 *in, int16 *out, uint32 pitch,
+                       int blkSize) {
+    int		x, y;
+    int16	dcCoeff;
 
-    dc_coeff = (*in + 0) >> 3;
+    dcCoeff = (*in + 0) >> 3;
 
-    for (y = 0; y < blk_size; out += pitch, y++) {
-        for (x = 0; x < blk_size; x++)
-            out[x] = dc_coeff;
+    for (y = 0; y < blkSize; out += pitch, y++) {
+        for (x = 0; x < blkSize; x++)
+            out[x] = dcCoeff;
     }
 }
 
@@ -334,12 +334,12 @@ void IndeoDSP::ff_ivi_dc_haar_2d(const int32 *in, int16 *out, uint32 pitch,
     d3 = COMPENSATE(t3);\
     d4 = COMPENSATE(t4);}
 
-void IndeoDSP::ff_ivi_inverse_slant_8x8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
-    int     i;
+void IndeoDSP::ffIviInverseSlant8x8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
+    int		i;
     const int32 *src;
-    int32 *dst;
-    int     tmp[64];
-    int     t0, t1, t2, t3, t4, t5, t6, t7, t8;
+    int32 *	dst;
+    int		tmp[64];
+    int		t0, t1, t2, t3, t4, t5, t6, t7, t8;
 
 #define COMPENSATE(x) (x)
     src = in;
@@ -374,12 +374,12 @@ void IndeoDSP::ff_ivi_inverse_slant_8x8(const int32 *in, int16 *out, uint32 pitc
 #undef COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_inverse_slant_4x4(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
-    int     i;
+void IndeoDSP::ffIviInverseSlant4x4(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
+    int		i;
     const int32 *src;
-    int32 *dst;
-    int     tmp[16];
-    int     t0, t1, t2, t3, t4;
+    int32 *	dst;
+    int		tmp[16];
+    int		t0, t1, t2, t3, t4;
 
 #define COMPENSATE(x) (x)
     src = in;
@@ -413,23 +413,23 @@ void IndeoDSP::ff_ivi_inverse_slant_4x4(const int32 *in, int16 *out, uint32 pitc
 #undef COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_dc_slant_2d(const int32 *in, int16 *out, uint32 pitch,
-		int blk_size) {
-    int     x, y;
-    int16 dc_coeff;
+void IndeoDSP::ffIviDcSlant2d(const int32 *in, int16 *out, uint32 pitch,
+		int blkSize) {
+    int		x, y;
+    int16	dcCoeff;
 
-    dc_coeff = (*in + 1) >> 1;
+    dcCoeff = (*in + 1) >> 1;
 
-    for (y = 0; y < blk_size; out += pitch, y++) {
-        for (x = 0; x < blk_size; x++)
-            out[x] = dc_coeff;
+    for (y = 0; y < blkSize; out += pitch, y++) {
+        for (x = 0; x < blkSize; x++)
+            out[x] = dcCoeff;
     }
 }
 
-void IndeoDSP::ff_ivi_row_slant8(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviRowSlant8(const int32 *in, int16 *out, uint32 pitch,
 		const uint8 *flags) {
-    int     i;
-    int     t0, t1, t2, t3, t4, t5, t6, t7, t8;
+    int		i;
+    int		t0, t1, t2, t3, t4, t5, t6, t7, t8;
 
 #define COMPENSATE(x) (((x) + 1)>>1)
     for (i = 0; i < 8; i++) {
@@ -446,26 +446,26 @@ void IndeoDSP::ff_ivi_row_slant8(const int32 *in, int16 *out, uint32 pitch,
 #undef COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_dc_row_slant(const int32 *in, int16 *out, uint32 pitch, int blk_size) {
-    int     x, y;
-    int16 dc_coeff;
+void IndeoDSP::ffIviDcRowSlant(const int32 *in, int16 *out, uint32 pitch, int blkSize) {
+    int		x, y;
+    int16	dcCoeff;
 
-    dc_coeff = (*in + 1) >> 1;
+    dcCoeff = (*in + 1) >> 1;
 
-    for (x = 0; x < blk_size; x++)
-        out[x] = dc_coeff;
+    for (x = 0; x < blkSize; x++)
+        out[x] = dcCoeff;
 
     out += pitch;
 
-    for (y = 1; y < blk_size; out += pitch, y++) {
-        for (x = 0; x < blk_size; x++)
+    for (y = 1; y < blkSize; out += pitch, y++) {
+        for (x = 0; x < blkSize; x++)
             out[x] = 0;
     }
 }
 
-void IndeoDSP::ff_ivi_col_slant8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
-    int     i, row2, row4, row8;
-    int     t0, t1, t2, t3, t4, t5, t6, t7, t8;
+void IndeoDSP::ffIviColSlant8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
+    int		i, row2, row4, row8;
+    int		t0, t1, t2, t3, t4, t5, t6, t7, t8;
 
     row2 = pitch << 1;
     row4 = pitch << 2;
@@ -489,23 +489,23 @@ void IndeoDSP::ff_ivi_col_slant8(const int32 *in, int16 *out, uint32 pitch, cons
 #undef COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_dc_col_slant(const int32 *in, int16 *out, uint32 pitch, int blk_size) {
-    int     x, y;
-    int16 dc_coeff;
+void IndeoDSP::ffIviDcColSlant(const int32 *in, int16 *out, uint32 pitch, int blkSize) {
+    int		x, y;
+    int16	dcCoeff;
 
-    dc_coeff = (*in + 1) >> 1;
+    dcCoeff = (*in + 1) >> 1;
 
-    for (y = 0; y < blk_size; out += pitch, y++) {
-        out[0] = dc_coeff;
-        for (x = 1; x < blk_size; x++)
+    for (y = 0; y < blkSize; out += pitch, y++) {
+        out[0] = dcCoeff;
+        for (x = 1; x < blkSize; x++)
             out[x] = 0;
     }
 }
 
-void IndeoDSP::ff_ivi_row_slant4(const int32 *in, int16 *out,
+void IndeoDSP::ffIviRowSlant4(const int32 *in, int16 *out,
 		uint32 pitch, const uint8 *flags) {
-    int     i;
-    int     t0, t1, t2, t3, t4;
+    int		i;
+    int		t0, t1, t2, t3, t4;
 
 #define COMPENSATE(x) (((x) + 1)>>1)
     for (i = 0; i < 4; i++) {
@@ -522,10 +522,10 @@ void IndeoDSP::ff_ivi_row_slant4(const int32 *in, int16 *out,
 #undef COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_col_slant4(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviColSlant4(const int32 *in, int16 *out, uint32 pitch,
 		const uint8 *flags) {
-    int     i, row2;
-    int     t0, t1, t2, t3, t4;
+    int		i, row2;
+    int		t0, t1, t2, t3, t4;
 
     row2 = pitch << 1;
 
@@ -545,18 +545,18 @@ void IndeoDSP::ff_ivi_col_slant4(const int32 *in, int16 *out, uint32 pitch,
 #undef COMPENSATE
 }
 
-void IndeoDSP::ff_ivi_put_pixels_8x8(const int32 *in, int16 *out, uint32 pitch,
+void IndeoDSP::ffIviPutPixels8x8(const int32 *in, int16 *out, uint32 pitch,
 		const uint8 *flags) {
-    int     x, y;
+    int		x, y;
 
     for (y = 0; y < 8; out += pitch, in += 8, y++)
         for (x = 0; x < 8; x++)
             out[x] = in[x];
 }
 
-void IndeoDSP::ff_ivi_put_dc_pixel_8x8(const int32 *in, int16 *out, uint32 pitch,
-		int blk_size) {
-    int     y;
+void IndeoDSP::ffIviPutDcPixel8x8(const int32 *in, int16 *out, uint32 pitch,
+		int blkSize) {
+    int		y;
 
     out[0] = in[0];
     memset(out + 1, 0, 7*sizeof(out[0]));
@@ -567,60 +567,60 @@ void IndeoDSP::ff_ivi_put_dc_pixel_8x8(const int32 *in, int16 *out, uint32 pitch
 }
 
 #define IVI_MC_TEMPLATE(size, suffix, OP) \
-static void ivi_mc_ ## size ##x## size ## suffix(int16 *buf, \
+static void iviMc ## size ##x## size ## suffix(int16 *buf, \
                                                  uint32 dpitch, \
-                                                 const int16 *ref_buf, \
-                                                 uint32 pitch, int mc_type) \
+                                                 const int16 *refBuf, \
+                                                 uint32 pitch, int mcType) \
 { \
-    int     i, j; \
+    int	i, j; \
     const int16 *wptr; \
 \
-    switch (mc_type) { \
+    switch (mcType) { \
     case 0: /* fullpel (no interpolation) */ \
-        for (i = 0; i < size; i++, buf += dpitch, ref_buf += pitch) { \
+        for (i = 0; i < size; i++, buf += dpitch, refBuf += pitch) { \
             for (j = 0; j < size; j++) {\
-                OP(buf[j], ref_buf[j]); \
+                OP(buf[j], refBuf[j]); \
             } \
         } \
         break; \
     case 1: /* horizontal halfpel interpolation */ \
-        for (i = 0; i < size; i++, buf += dpitch, ref_buf += pitch) \
+        for (i = 0; i < size; i++, buf += dpitch, refBuf += pitch) \
             for (j = 0; j < size; j++) \
-                OP(buf[j], (ref_buf[j] + ref_buf[j+1]) >> 1); \
+                OP(buf[j], (refBuf[j] + refBuf[j+1]) >> 1); \
         break; \
     case 2: /* vertical halfpel interpolation */ \
-        wptr = ref_buf + pitch; \
-        for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, ref_buf += pitch) \
+        wptr = refBuf + pitch; \
+        for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, refBuf += pitch) \
             for (j = 0; j < size; j++) \
-                OP(buf[j], (ref_buf[j] + wptr[j]) >> 1); \
+                OP(buf[j], (refBuf[j] + wptr[j]) >> 1); \
         break; \
     case 3: /* vertical and horizontal halfpel interpolation */ \
-        wptr = ref_buf + pitch; \
-        for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, ref_buf += pitch) \
+        wptr = refBuf + pitch; \
+        for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, refBuf += pitch) \
             for (j = 0; j < size; j++) \
-                OP(buf[j], (ref_buf[j] + ref_buf[j+1] + wptr[j] + wptr[j+1]) >> 2); \
+                OP(buf[j], (refBuf[j] + refBuf[j+1] + wptr[j] + wptr[j+1]) >> 2); \
         break; \
     } \
 } \
 \
-void IndeoDSP::ff_ivi_mc_ ## size ##x## size ## suffix(int16 *buf, const int16 *ref_buf, \
-                                             uint32 pitch, int mc_type) \
+void IndeoDSP::ffIviMc ## size ##x## size ## suffix(int16 *buf, const int16 *refBuf, \
+                                             uint32 pitch, int mcType) \
 { \
-    ivi_mc_ ## size ##x## size ## suffix(buf, pitch, ref_buf, pitch, mc_type); \
+    iviMc ## size ##x## size ## suffix(buf, pitch, refBuf, pitch, mcType); \
 }
 
 #define IVI_MC_AVG_TEMPLATE(size, suffix, OP) \
-void IndeoDSP::ff_ivi_mc_avg_ ## size ##x## size ## suffix(int16 *buf, \
-                                                 const int16 *ref_buf, \
-                                                 const int16 *ref_buf2, \
+void IndeoDSP::ffIviMcAvg ## size ##x## size ## suffix(int16 *buf, \
+                                                 const int16 *refBuf, \
+                                                 const int16 *refBuf2, \
                                                  uint32 pitch, \
-                                               int mc_type, int mc_type2) \
+                                               int mcType, int mcType2) \
 { \
     int16 tmp[size * size]; \
     int i, j; \
 \
-    ivi_mc_ ## size ##x## size ## _no_delta(tmp, size, ref_buf, pitch, mc_type); \
-    ivi_mc_ ## size ##x## size ## _delta(tmp, size, ref_buf2, pitch, mc_type2); \
+    iviMc ## size ##x## size ## NoDelta(tmp, size, refBuf, pitch, mcType); \
+    iviMc ## size ##x## size ## Delta(tmp, size, refBuf2, pitch, mcType2); \
     for (i = 0; i < size; i++, buf += pitch) { \
         for (j = 0; j < size; j++) {\
             OP(buf[j], tmp[i * size + j] >> 1); \
@@ -631,14 +631,14 @@ void IndeoDSP::ff_ivi_mc_avg_ ## size ##x## size ## suffix(int16 *buf, \
 #define OP_PUT(a, b)  (a) = (b)
 #define OP_ADD(a, b)  (a) += (b)
 
-IVI_MC_TEMPLATE(8, _no_delta, OP_PUT)
-IVI_MC_TEMPLATE(8, _delta,    OP_ADD)
-IVI_MC_TEMPLATE(4, _no_delta, OP_PUT)
-IVI_MC_TEMPLATE(4, _delta,    OP_ADD)
-IVI_MC_AVG_TEMPLATE(8, _no_delta, OP_PUT)
-IVI_MC_AVG_TEMPLATE(8, _delta,    OP_ADD)
-IVI_MC_AVG_TEMPLATE(4, _no_delta, OP_PUT)
-IVI_MC_AVG_TEMPLATE(4, _delta,    OP_ADD)
+IVI_MC_TEMPLATE(8, NoDelta, OP_PUT)
+IVI_MC_TEMPLATE(8, Delta,   OP_ADD)
+IVI_MC_TEMPLATE(4, NoDelta, OP_PUT)
+IVI_MC_TEMPLATE(4, Delta,   OP_ADD)
+IVI_MC_AVG_TEMPLATE(8, NoDelta, OP_PUT)
+IVI_MC_AVG_TEMPLATE(8, Delta,   OP_ADD)
+IVI_MC_AVG_TEMPLATE(4, NoDelta, OP_PUT)
+IVI_MC_AVG_TEMPLATE(4, Delta,   OP_ADD)
 
 } // End of namespace Indeo
 } // End of namespace Image
diff --git a/image/codecs/indeo/indeo_dsp.h b/image/codecs/indeo/indeo_dsp.h
index fc503397cf..5f4b04f9db 100644
--- a/image/codecs/indeo/indeo_dsp.h
+++ b/image/codecs/indeo/indeo_dsp.h
@@ -43,293 +43,293 @@ public:
 	/**
 	 *  two-dimensional inverse Haar 8x8 transform for Indeo 4
 	 *
-	 *  @param[in]  in        pointer to the vector of transform coefficients
-	 *  @param[out] out       pointer to the output buffer (frame)
-	 *  @param[in]  pitch     pitch to move to the next y line
-	 *  @param[in]  flags     pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_inverse_haar_8x8(const int32 *in, int16 *out, uint32 pitch,
-								 const uint8 *flags);
-	static void ff_ivi_inverse_haar_8x1(const int32 *in, int16 *out, uint32 pitch,
-								 const uint8 *flags);
-	static void ff_ivi_inverse_haar_1x8(const int32 *in, int16 *out, uint32 pitch,
-								 const uint8 *flags);
+	static void ffIviInverseHaar8x8(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
+	static void ffIviInverseHaar8x1(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
+	static void ffIviInverseHaar1x8(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  one-dimensional inverse 8-point Haar transform on rows for Indeo 4
 	 *
-	 *  @param[in]  in        pointer to the vector of transform coefficients
-	 *  @param[out] out       pointer to the output buffer (frame)
-	 *  @param[in]  pitch     pitch to move to the next y line
-	 *  @param[in]  flags     pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_row_haar8(const int32 *in, int16 *out, uint32 pitch,
-						  const uint8 *flags);
+	static void ffIviRowHaar8(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  one-dimensional inverse 8-point Haar transform on columns for Indeo 4
 	 *
-	 *  @param[in]  in        pointer to the vector of transform coefficients
-	 *  @param[out] out       pointer to the output buffer (frame)
-	 *  @param[in]  pitch     pitch to move to the next y line
-	 *  @param[in]  flags     pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_col_haar8(const int32 *in, int16 *out, uint32 pitch,
-						  const uint8 *flags);
+	static void ffIviColHaar8(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  two-dimensional inverse Haar 4x4 transform for Indeo 4
 	 *
-	 *  @param[in]  in        pointer to the vector of transform coefficients
-	 *  @param[out] out       pointer to the output buffer (frame)
-	 *  @param[in]  pitch     pitch to move to the next y line
-	 *  @param[in]  flags     pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_inverse_haar_4x4(const int32 *in, int16 *out, uint32 pitch,
-								 const uint8 *flags);
+	static void ffIviInverseHaar4x4(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  one-dimensional inverse 4-point Haar transform on rows for Indeo 4
 	 *
-	 *  @param[in]  in        pointer to the vector of transform coefficients
-	 *  @param[out] out       pointer to the output buffer (frame)
-	 *  @param[in]  pitch     pitch to move to the next y line
-	 *  @param[in]  flags     pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_row_haar4(const int32 *in, int16 *out, uint32 pitch,
-						  const uint8 *flags);
+	static void ffIviRowHaar4(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  one-dimensional inverse 4-point Haar transform on columns for Indeo 4
 	 *
-	 *  @param[in]  in        pointer to the vector of transform coefficients
-	 *  @param[out] out       pointer to the output buffer (frame)
-	 *  @param[in]  pitch     pitch to move to the next y line
-	 *  @param[in]  flags     pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_col_haar4(const int32 *in, int16 *out, uint32 pitch,
+	static void ffIviColHaar4(const int32 *in, int16 *out, uint32 pitch,
 						  const uint8 *flags);
 
 	/**
 	 *  DC-only two-dimensional inverse Haar transform for Indeo 4.
 	 *  Performing the inverse transform in this case is equivalent to
-	 *  spreading DC_coeff >> 3 over the whole block.
+	 *  spreading dcCoeff >> 3 over the whole block.
 	 *
-	 *  @param[in]  in          pointer to the dc coefficient
-	 *  @param[out] out         pointer to the output buffer (frame)
-	 *  @param[in]  pitch       pitch to move to the next y line
-	 *  @param[in]  blk_size    transform block size
+	 *  @param[in]  in			Pointer to the dc coefficient
+	 *  @param[out] out			Pointer to the output buffer (frame)
+	 *  @param[in]  pitch		Pitch to move to the next y line
+	 *  @param[in]  blkSize		Transform block size
 	 */
-	static void ff_ivi_dc_haar_2d(const int32 *in, int16 *out, uint32 pitch,
-						   int blk_size);
+	static void ffIviDcHaar2d(const int32 *in, int16 *out, uint32 pitch,
+		int blkSize);
 
 	/**
 	 *  two-dimensional inverse slant 8x8 transform
 	 *
-	 *  @param[in]    in      pointer to the vector of transform coefficients
-	 *  @param[out]   out     pointer to the output buffer (frame)
-	 *  @param[in]    pitch   pitch to move to the next y line
-	 *  @param[in]    flags   pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_inverse_slant_8x8(const int32 *in, int16 *out, uint32 pitch,
-								  const uint8 *flags);
+	static void ffIviInverseSlant8x8(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  two-dimensional inverse slant 4x4 transform
 	 *
-	 *  @param[in]    in      pointer to the vector of transform coefficients
-	 *  @param[out]   out     pointer to the output buffer (frame)
-	 *  @param[in]    pitch   pitch to move to the next y line
-	 *  @param[in]    flags   pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_inverse_slant_4x4(const int32 *in, int16 *out, uint32 pitch,
-								  const uint8 *flags);
+	static void ffIviInverseSlant4x4(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  DC-only two-dimensional inverse slant transform.
 	 *  Performing the inverse slant transform in this case is equivalent to
-	 *  spreading (DC_coeff + 1)/2 over the whole block.
+	 *  spreading (dcCoeff + 1)/2 over the whole block.
 	 *  It works much faster than performing the slant transform on a vector of zeroes.
 	 *
-	 *  @param[in]    in          pointer to the dc coefficient
-	 *  @param[out]   out         pointer to the output buffer (frame)
-	 *  @param[in]    pitch       pitch to move to the next y line
-	 *  @param[in]    blk_size    transform block size
+	 *  @param[in]  in			Pointer to the dc coefficient
+	 *  @param[out] out			Pointer to the output buffer (frame)
+	 *  @param[in]  pitch		Pitch to move to the next y line
+	 *  @param[in]  blkSize		Transform block size
 	 */
-	static void ff_ivi_dc_slant_2d(const int32 *in, int16 *out, uint32 pitch, int blk_size);
+	static void ffIviDcSlant2d(const int32 *in, int16 *out, uint32 pitch, int blkSize);
 
 	/**
 	 *  inverse 1D row slant transform
 	 *
-	 *  @param[in]    in      pointer to the vector of transform coefficients
-	 *  @param[out]   out     pointer to the output buffer (frame)
-	 *  @param[in]    pitch   pitch to move to the next y line
-	 *  @param[in]    flags   pointer to the array of column flags (unused here)
+	 *  @param[in]    in		Pointer to the vector of transform coefficients
+	 *  @param[out]   out		Pointer to the output buffer (frame)
+	 *  @param[in]    pitch		Pitch to move to the next y line
+	 *  @param[in]    flags		Pointer to the array of column flags (unused here)
 	 */
-	static void ff_ivi_row_slant8(const int32 *in, int16 *out, uint32 pitch,
-						   const uint8 *flags);
+	static void ffIviRowSlant8(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  inverse 1D column slant transform
 	 *
-	 *  @param[in]    in      pointer to the vector of transform coefficients
-	 *  @param[out]   out     pointer to the output buffer (frame)
-	 *  @param[in]    pitch   pitch to move to the next y line
-	 *  @param[in]    flags   pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_col_slant8(const int32 *in, int16 *out, uint32 pitch,
-						   const uint8 *flags);
+	static void ffIviColSlant8(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  inverse 1D row slant transform
 	 *
-	 *  @param[in]    in      pointer to the vector of transform coefficients
-	 *  @param[out]   out     pointer to the output buffer (frame)
-	 *  @param[in]    pitch   pitch to move to the next y line
-	 *  @param[in]    flags   pointer to the array of column flags (unused here)
+	 *  @param[in]    in		Pointer to the vector of transform coefficients
+	 *  @param[out]   out		Pointer to the output buffer (frame)
+	 *  @param[in]    pitch		Pitch to move to the next y line
+	 *  @param[in]    flags		Pointer to the array of column flags (unused here)
 	 */
-	static void ff_ivi_row_slant4(const int32 *in, int16 *out, uint32 pitch,
-						   const uint8 *flags);
+	static void ffIviRowSlant4(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  inverse 1D column slant transform
 	 *
-	 *  @param[in]    in      pointer to the vector of transform coefficients
-	 *  @param[out]   out     pointer to the output buffer (frame)
-	 *  @param[in]    pitch   pitch to move to the next y line
-	 *  @param[in]    flags   pointer to the array of column flags:
-	 *                        != 0 - non_empty column, 0 - empty one
-	 *                        (this array must be filled by caller)
+	 *  @param[in]  in		Pointer to the vector of transform coefficients
+	 *  @param[out] out		Pointer to the output buffer (frame)
+	 *  @param[in]  pitch	Pitch to move to the next y line
+	 *  @param[in]  flags	Pointer to the array of column flags:
+	 *						!= 0 - non_empty column, 0 - empty one
+	 *						(this array must be filled by caller)
 	 */
-	static void ff_ivi_col_slant4(const int32 *in, int16 *out, uint32 pitch,
-						   const uint8 *flags);
+	static void ffIviColSlant4(const int32 *in, int16 *out, uint32 pitch,
+		const uint8 *flags);
 
 	/**
 	 *  DC-only inverse row slant transform
 	 */
-	static void ff_ivi_dc_row_slant(const int32 *in, int16 *out, uint32 pitch, int blk_size);
+	static void ffIviDcRowSlant(const int32 *in, int16 *out, uint32 pitch, int blkSize);
 
 	/**
 	 *  DC-only inverse column slant transform
 	 */
-	static void ff_ivi_dc_col_slant(const int32 *in, int16 *out, uint32 pitch, int blk_size);
+	static void ffIviDcColSlant(const int32 *in, int16 *out, uint32 pitch, int blkSize);
 
 	/**
 	 *  Copy the pixels into the frame buffer.
 	 */
-	static void ff_ivi_put_pixels_8x8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags);
+	static void ffIviPutPixels8x8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags);
 
 	/**
 	 *  Copy the DC coefficient into the first pixel of the block and
 	 *  zero all others.
 	 */
-	static void ff_ivi_put_dc_pixel_8x8(const int32 *in, int16 *out, uint32 pitch, int blk_size);
+	static void ffIviPutDcPixel8x8(const int32 *in, int16 *out, uint32 pitch, int blkSize);
 
 	/**
 	 *  8x8 block motion compensation with adding delta
 	 *
-	 *  @param[in,out]   buf      pointer to the block in the current frame buffer containing delta
-	 *  @param[in]       ref_buf  pointer to the corresponding block in the reference frame
-	 *  @param[in]       pitch    pitch for moving to the next y line
-	 *  @param[in]       mc_type  interpolation type
+	 *  @param[in,out]   buf		Pointer to the block in the current frame buffer containing delta
+	 *  @param[in]       refBuf		Pointer to the corresponding block in the reference frame
+	 *  @param[in]       pitch		Pitch for moving to the next y line
+	 *  @param[in]       mcType		Interpolation type
 	 */
-	static void ff_ivi_mc_8x8_delta(int16 *buf, const int16 *ref_buf, uint32 pitch, int mc_type);
+	static void ffIviMc8x8Delta(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
 
 	/**
 	 *  4x4 block motion compensation with adding delta
 	 *
-	 *  @param[in,out]   buf      pointer to the block in the current frame buffer containing delta
-	 *  @param[in]       ref_buf  pointer to the corresponding block in the reference frame
-	 *  @param[in]       pitch    pitch for moving to the next y line
-	 *  @param[in]       mc_type  interpolation type
+	 *  @param[in,out]   buf		Pointer to the block in the current frame buffer containing delta
+	 *  @param[in]       refBuf		Pointer to the corresponding block in the reference frame
+	 *  @param[in]       pitch		Pitch for moving to the next y line
+	 *  @param[in]       mcType		Interpolation type
 	 */
-	static void ff_ivi_mc_4x4_delta(int16 *buf, const int16 *ref_buf, uint32 pitch, int mc_type);
+	static void ffIviMc4x4Delta(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
 
 	/**
 	 *  motion compensation without adding delta
 	 *
-	 *  @param[in,out]  buf      pointer to the block in the current frame receiving the result
-	 *  @param[in]      ref_buf  pointer to the corresponding block in the reference frame
-	 *  @param[in]      pitch    pitch for moving to the next y line
-	 *  @param[in]      mc_type  interpolation type
+	 *  @param[in,out]   buf		Pointer to the block in the current frame buffer containing delta
+	 *  @param[in]       refBuf		Pointer to the corresponding block in the reference frame
+	 *  @param[in]       pitch		Pitch for moving to the next y line
+	 *  @param[in]       mcType		Interpolation type
 	 */
-	static void ff_ivi_mc_8x8_no_delta(int16 *buf, const int16 *ref_buf, uint32 pitch, int mc_type);
+	static void ffIviMc8x8NoDelta(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
 
 	/**
 	 *  4x4 block motion compensation without adding delta
 	 *
-	 *  @param[in,out]  buf      pointer to the block in the current frame receiving the result
-	 *  @param[in]      ref_buf  pointer to the corresponding block in the reference frame
-	 *  @param[in]      pitch    pitch for moving to the next y line
-	 *  @param[in]      mc_type  interpolation type
+	 *  @param[in,out]  buf			Pointer to the block in the current frame receiving the result
+	 *  @param[in]      refBuf		Pointer to the corresponding block in the reference frame
+	 *  @param[in]      pitch		Pitch for moving to the next y line
+	 *  @param[in]      mcType		Interpolation type
 	 */
-	static void ff_ivi_mc_4x4_no_delta(int16 *buf, const int16 *ref_buf, uint32 pitch, int mc_type);
+	static void ffIviMc4x4NoDelta(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
 
 	/**
 	 *  8x8 block motion compensation with adding delta
 	 *
-	 *  @param[in,out]  buf      pointer to the block in the current frame buffer containing delta
-	 *  @param[in]      ref_buf  pointer to the corresponding block in the backward reference frame
-	 *  @param[in]      ref_buf2 pointer to the corresponding block in the forward reference frame
-	 *  @param[in]      pitch    pitch for moving to the next y line
-	 *  @param[in]      mc_type  interpolation type for backward reference
-	 *  @param[in]      mc_type2 interpolation type for forward reference
+	 *  @param[in,out]  buf			Pointer to the block in the current frame buffer containing delta
+	 *  @param[in]      refBuf		Pointer to the corresponding block in the backward reference frame
+	 *  @param[in]      refBuf2		Pointer to the corresponding block in the forward reference frame
+	 *  @param[in]      pitch		Pitch for moving to the next y line
+	 *  @param[in]      mcType		Interpolation type for backward reference
+	 *  @param[in]      mcType2		Interpolation type for forward reference
 	 */
-	static void ff_ivi_mc_avg_8x8_delta(int16 *buf, const int16 *ref_buf, const int16 *ref_buf2, uint32 pitch, int mc_type, int mc_type2);
+	static void ffIviMcAvg8x8Delta(int16 *buf, const int16 *refBuf, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2);
 
 	/**
 	 *  4x4 block motion compensation with adding delta
 	 *
-	 *  @param[in,out]  buf      pointer to the block in the current frame buffer containing delta
-	 *  @param[in]      ref_buf  pointer to the corresponding block in the backward reference frame
-	 *  @param[in]      ref_buf2 pointer to the corresponding block in the forward reference frame
-	 *  @param[in]      pitch    pitch for moving to the next y line
-	 *  @param[in]      mc_type  interpolation type for backward reference
-	 *  @param[in]      mc_type2 interpolation type for forward reference
+	 *  @param[in,out]  buf			Pointer to the block in the current frame buffer containing delta
+	 *  @param[in]      refBuf		Pointer to the corresponding block in the backward reference frame
+	 *  @param[in]      refBuf2		Pointer to the corresponding block in the forward reference frame
+	 *  @param[in]      pitch		Pitch for moving to the next y line
+	 *  @param[in]      mcType		Interpolation type for backward reference
+	 *  @param[in]      mcType2		Interpolation type for forward reference
 	 */
-	static void ff_ivi_mc_avg_4x4_delta(int16 *buf, const int16 *ref_buf, const int16 *ref_buf2, uint32 pitch, int mc_type, int mc_type2);
+	static void ffIviMcAvg4x4Delta(int16 *buf, const int16 *refBuf, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2);
 
 	/**
 	 *  motion compensation without adding delta for B-frames
 	 *
-	 *  @param[in,out]  buf      pointer to the block in the current frame receiving the result
-	 *  @param[in]      ref_buf  pointer to the corresponding block in the backward reference frame
-	 *  @param[in]      ref_buf2 pointer to the corresponding block in the forward reference frame
-	 *  @param[in]      pitch    pitch for moving to the next y line
-	 *  @param[in]      mc_type  interpolation type for backward reference
-	 *  @param[in]      mc_type2 interpolation type for forward reference
+	 *  @param[in,out]  buf			Pointer to the block in the current frame buffer containing delta
+	 *  @param[in]      refBuf		Pointer to the corresponding block in the backward reference frame
+	 *  @param[in]      refBuf2		Pointer to the corresponding block in the forward reference frame
+	 *  @param[in]      pitch		Pitch for moving to the next y line
+	 *  @param[in]      mcType		Interpolation type for backward reference
+	 *  @param[in]      mcType2		Interpolation type for forward reference
 	 */
-	static void ff_ivi_mc_avg_8x8_no_delta(int16 *buf, const int16 *ref_buf, const int16 *ref_buf2, uint32 pitch, int mc_type, int mc_type2);
+	static void ffIviMcAvg8x8NoDelta(int16 *buf, const int16 *refBuf, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2);
 
 	/**
 	 *  4x4 block motion compensation without adding delta for B-frames
 	 *
-	 *  @param[in,out]  buf      pointer to the block in the current frame receiving the result
-	 *  @param[in]      ref_buf  pointer to the corresponding block in the backward reference frame
-	 *  @param[in]      ref_buf2 pointer to the corresponding block in the forward reference frame
-	 *  @param[in]      pitch    pitch for moving to the next y line
-	 *  @param[in]      mc_type  interpolation type for backward reference
-	 *  @param[in]      mc_type2 interpolation type for forward reference
+	 *  @param[in,out]  buf			Pointer to the block in the current frame buffer containing delta
+	 *  @param[in]      refBuf		Pointer to the corresponding block in the backward reference frame
+	 *  @param[in]      refBuf2		Pointer to the corresponding block in the forward reference frame
+	 *  @param[in]      pitch		Pitch for moving to the next y line
+	 *  @param[in]      mcType		Interpolation type for backward reference
+	 *  @param[in]      mcType2		Interpolation type for forward reference
 	 */
-	static void ff_ivi_mc_avg_4x4_no_delta(int16 *buf, const int16 *ref_buf, const int16 *ref_buf2, uint32 pitch, int mc_type, int mc_type2);
+	static void ffIviMcAvg4x4NoDelta(int16 *buf, const int16 *refBuf, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2);
 };
 
 } // End of namespace Indeo
diff --git a/image/codecs/indeo/mem.cpp b/image/codecs/indeo/mem.cpp
index 9987415799..89f2af7ad2 100644
--- a/image/codecs/indeo/mem.cpp
+++ b/image/codecs/indeo/mem.cpp
@@ -31,7 +31,7 @@
 namespace Image {
 namespace Indeo {
 
-const uint8 ff_reverse[256] = {
+const uint8 ffReverse[256] = {
 	0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, 
 	0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 
 	0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 
@@ -50,6 +50,17 @@ const uint8 ff_reverse[256] = {
 	0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF, 
 };
 
+const uint8 ffZigZagDirect[64] = {
+	0,   1,  8, 16,  9,  2,  3, 10,
+	17, 24, 32, 25, 18, 11,  4,  5,
+	12, 19, 26, 33, 40, 48, 41, 34,
+	27, 20, 13,  6,  7, 14, 21, 28,
+	35, 42, 49, 56, 57, 50, 43, 36,
+	29, 22, 15, 23, 30, 37, 44, 51,
+	58, 59, 52, 45, 38, 31, 39, 46,
+	53, 60, 61, 54, 47, 55, 62, 63
+};
+
 /*------------------------------------------------------------------------*/
 
 /**
@@ -59,7 +70,7 @@ const uint8 ff_reverse[256] = {
  * @param[out] r   Pointer to the result of the operation
  * @return 0 on success, AVERROR(EINVAL) on overflow
  */
-static inline int av_size_mult(size_t a, size_t b, size_t *r) {
+static inline int avSizeMult(size_t a, size_t b, size_t *r) {
     size_t t = a * b;
 
     // Hack inspired from glibc: don't try the division if nelem and elsize
@@ -72,56 +83,56 @@ static inline int av_size_mult(size_t a, size_t b, size_t *r) {
 
 /*------------------------------------------------------------------------*/
 
-void *av_malloc(size_t size) {
+void *avMalloc(size_t size) {
 	return malloc(size);
 }
 
-void *av_mallocz(size_t size) {
-	void *ptr = av_malloc(size);
+void *avMallocZ(size_t size) {
+	void *ptr = avMalloc(size);
 	if (ptr)
 		memset(ptr, 0, size);
 
 	return ptr;
 }
 
-void *av_malloc_array(size_t nmemb, size_t size) {
+void *avMallocArray(size_t nmemb, size_t size) {
     if (!size || nmemb >= MAX_INTEGER / size)
         return nullptr;
     return malloc(nmemb * size);
 }
 
-void *av_mallocz_array(size_t nmemb, size_t size) {
+void *avMallocZArray(size_t nmemb, size_t size) {
 	if (!size || nmemb >= MAX_INTEGER / size)
 		return NULL;
 
-	return av_mallocz(nmemb * size);
+	return avMallocZ(nmemb * size);
 }
 
-void av_free(void *ptr) {
+void avFree(void *ptr) {
 	free(ptr);
 }
 
-void av_freep(void *arg) {
+void avFreeP(void *arg) {
 	void **ptr = (void **)arg;
 	free(*ptr);
 	*ptr = nullptr;
 }
 
-static void *av_realloc(void *ptr, size_t size) {
+static void *avRealloc(void *ptr, size_t size) {
 	return realloc(ptr, size + !size);
 }
 
-void *av_realloc_f(void *ptr, size_t nelem, size_t elsize) {
+void *avReallocF(void *ptr, size_t nelem, size_t elsize) {
 	size_t size;
 	void *r;
 
-	if (av_size_mult(elsize, nelem, &size)) {
-		av_free(ptr);
+	if (avSizeMult(elsize, nelem, &size)) {
+		avFree(ptr);
 		return nullptr;
 	}
-	r = av_realloc(ptr, size);
+	r = avRealloc(ptr, size);
 	if (!r)
-		av_free(ptr);
+		avFree(ptr);
 
 	return r;
 }
@@ -130,53 +141,39 @@ void *av_realloc_f(void *ptr, size_t nelem, size_t elsize) {
 /**
  * Swap the order of the bytes in the passed value
  */
-uint32 bitswap_32(uint32 x) {
-	return (uint32)ff_reverse[x & 0xFF] << 24 |
-		(uint32)ff_reverse[(x >> 8) & 0xFF] << 16 |
-		(uint32)ff_reverse[(x >> 16) & 0xFF] << 8 |
-		(uint32)ff_reverse[x >> 24];
+uint32 bitswap32(uint32 x) {
+	return (uint32)ffReverse[x & 0xFF] << 24 |
+		(uint32)ffReverse[(x >> 8) & 0xFF] << 16 |
+		(uint32)ffReverse[(x >> 16) & 0xFF] << 8 |
+		(uint32)ffReverse[x >> 24];
 }
 
 /**
  * Reverse "nbits" bits of the value "val" and return the result
  * in the least significant bits.
  */
-uint16 inv_bits(uint16 val, int nbits) {
+uint16 invertBits(uint16 val, int nbits) {
 	uint16 res;
 
 	if (nbits <= 8) {
-		res = ff_reverse[val] >> (8 - nbits);
+		res = ffReverse[val] >> (8 - nbits);
 	} else {
-		res = ((ff_reverse[val & 0xFF] << 8) +
-			(ff_reverse[val >> 8])) >> (16 - nbits);
+		res = ((ffReverse[val & 0xFF] << 8) +
+			(ffReverse[val >> 8])) >> (16 - nbits);
 	}
 
 	return res;
 }
 
-uint8 av_clip_uint8(int a) {
+uint8 avClipUint8(int a) {
 	if (a&(~0xFF)) return (-a) >> 31;
 	else           return a;
 }
 
-unsigned av_clip_uintp2(int a, int p) {
+unsigned avClipUintp2(int a, int p) {
 	if (a & ~((1 << p) - 1)) return -a >> 31 & ((1 << p) - 1);
 	else                   return  a;
 }
 
-
-/*------------------------------------------------------------------------*/
-
-const uint8 ff_zigzag_direct[64] = {
-	0,   1,  8, 16,  9,  2,  3, 10,
-	17, 24, 32, 25, 18, 11,  4,  5,
-	12, 19, 26, 33, 40, 48, 41, 34,
-	27, 20, 13,  6,  7, 14, 21, 28,
-	35, 42, 49, 56, 57, 50, 43, 36,
-	29, 22, 15, 23, 30, 37, 44, 51,
-	58, 59, 52, 45, 38, 31, 39, 46,
-	53, 60, 61, 54, 47, 55, 62, 63
-};
-
 } // End of namespace Indeo
 } // End of namespace Image
diff --git a/image/codecs/indeo/mem.h b/image/codecs/indeo/mem.h
index cc927e613a..7fadb147cb 100644
--- a/image/codecs/indeo/mem.h
+++ b/image/codecs/indeo/mem.h
@@ -49,7 +49,7 @@ namespace Indeo {
  *         be allocated
  * @see av_mallocz()
  */
-extern void *av_malloc(size_t size);
+extern void *avMalloc(size_t size);
 
 /**
  * Allocate a memory block with alignment suitable for all memory accesses
@@ -60,7 +60,7 @@ extern void *av_malloc(size_t size);
  * @return Pointer to the allocated block, or `NULL` if it cannot be allocated
  * @see av_malloc()
  */
-extern void *av_mallocz(size_t size);
+extern void *avMallocZ(size_t size);
 
 /**
  * Allocate a memory block for an array with av_malloc().
@@ -73,7 +73,7 @@ extern void *av_mallocz(size_t size);
  *         be allocated
  * @see av_malloc()
  */
-extern void *av_malloc_array(size_t nmemb, size_t size);
+extern void *avMallocArray(size_t nmemb, size_t size);
 
 /**
  * Allocate a memory block for an array with av_mallocz().
@@ -88,7 +88,7 @@ extern void *av_malloc_array(size_t nmemb, size_t size);
  * @see av_mallocz()
  * @see av_malloc_array()
  */
-extern void *av_mallocz_array(size_t nmemb, size_t size);
+extern void *avMallocZArray(size_t nmemb, size_t size);
 
 /**
  * Free a memory block which has been allocated with a function of av_malloc()
@@ -101,7 +101,7 @@ extern void *av_mallocz_array(size_t nmemb, size_t size);
  *       behind dangling pointers.
  * @see av_freep()
  */
-extern void av_free(void *ptr);
+extern void avFree(void *ptr);
 
 /**
  * Free a memory block which has been allocated with a function of av_malloc()
@@ -110,7 +110,7 @@ extern void av_free(void *ptr);
  * @param ptr Pointer to the pointer to the memory block which should be freed
  * @note `*ptr = NULL` is safe and leads to no action.
  */
-extern void av_freep(void *arg);
+extern void avFreeP(void *arg);
 
 
 /**
@@ -128,25 +128,25 @@ extern void av_freep(void *arg);
  *   @endcode
  *   pattern.
  */
-extern void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
+extern void *avReallocF(void *ptr, size_t nelem, size_t elsize);
 
 /**
  * Reverse "nbits" bits of the value "val" and return the result
  * in the least significant bits.
  */
-extern uint16 inv_bits(uint16 val, int nbits);
+extern uint16 invertBits(uint16 val, int nbits);
 
 /**
  * Swap the order of the bytes in the passed value
  */
-extern uint32 bitswap_32(uint32 x);
+extern uint32 bitswap32(uint32 x);
 
 /**
  * Clip a signed integer value into the 0-255 range.
  * @param a value to clip
  * @return clipped value
  */
-extern uint8 av_clip_uint8(int a);
+extern uint8 avClipUint8(int a);
 
 /**
  * Clip a signed integer to an unsigned power of two range.
@@ -154,7 +154,7 @@ extern uint8 av_clip_uint8(int a);
  * @param  p bit position to clip at
  * @return clipped value
  */
-extern unsigned av_clip_uintp2(int a, int p);
+extern unsigned avClipUintp2(int a, int p);
 
 /**
 * Clip a signed integer value into the amin-amax range.
@@ -165,9 +165,7 @@ extern unsigned av_clip_uintp2(int a, int p);
 */
 #define av_clip CLIP
 
-/*------------------------------------------------------------------------*/
-
-extern const uint8 ff_zigzag_direct[64];
+extern const uint8 ffZigZagDirect[64];
 
 } // End of namespace Indeo
 } // End of namespace Image
diff --git a/image/codecs/indeo/vlc.cpp b/image/codecs/indeo/vlc.cpp
index 485acfbe53..0328bd8b70 100644
--- a/image/codecs/indeo/vlc.cpp
+++ b/image/codecs/indeo/vlc.cpp
@@ -123,7 +123,7 @@ namespace Image {
             return -1;                                                      \
         }                                                                   \
         if (flags & INIT_VLC_LE)                                            \
-            buf[j].code = bitswap_32(buf[j].code);                          \
+            buf[j].code = bitswap32(buf[j].code);                          \
         else                                                                \
             buf[j].code <<= 32 - buf[j].bits;                               \
         if (symbols)                                                        \
@@ -165,7 +165,7 @@ int VLC::init_vlc(int nb_bits, int nb_codes, const void *p_bits, int bits_wrap,
 		vlc->_table_allocated = 0;
 		vlc->_table_size = 0;
 
-		buf = (VLCcode *)av_malloc_array((nb_codes + 1), sizeof(VLCcode));
+		buf = (VLCcode *)avMallocArray((nb_codes + 1), sizeof(VLCcode));
 		assert(buf);
 	}
 
@@ -190,7 +190,7 @@ int VLC::init_vlc(int nb_bits, int nb_codes, const void *p_bits, int bits_wrap,
 	} else {
 		free(buf);
 		if (ret < 0) {
-			av_freep(&vlc->_table);
+			avFreeP(&vlc->_table);
 			return -1;
 		}
 	}
@@ -237,7 +237,7 @@ int VLC::build_table(int table_nb_bits, int nb_codes,
 			nb = 1 << (table_nb_bits - n);
 			inc = 1;
 			if (flags & INIT_VLC_LE) {
-				j = bitswap_32(code);
+				j = bitswap32(code);
 				inc = 1 << n;
 			}
 			for (k = 0; k < nb; k++) {
@@ -272,7 +272,7 @@ int VLC::build_table(int table_nb_bits, int nb_codes,
 				subtable_bits = MAX(subtable_bits, n);
 			}
 			subtable_bits = MIN(subtable_bits, table_nb_bits);
-			j = (flags & INIT_VLC_LE) ? bitswap_32(code_prefix) >> (32 - table_nb_bits) : code_prefix;
+			j = (flags & INIT_VLC_LE) ? bitswap32(code_prefix) >> (32 - table_nb_bits) : code_prefix;
 			table[j][1] = -subtable_bits;
 			//warning("%4x: n=%d (subtable)", j, codes[i].bits + table_nb_bits);
 			index = vlc->build_table(subtable_bits, k - i, codes + i, flags);
@@ -304,7 +304,7 @@ int VLC::alloc_table(int size, int use_static) {
 		assert(!use_static);
 
 		vlc->_table_allocated += (1 << vlc->_bits);
-		vlc->_table = (int16(*)[2])av_realloc_f(vlc->_table, vlc->_table_allocated, sizeof(VLC_TYPE) * 2);
+		vlc->_table = (int16(*)[2])avReallocF(vlc->_table, vlc->_table_allocated, sizeof(VLC_TYPE) * 2);
 		if (!vlc->_table) {
 			vlc->_table_allocated = 0;
 			vlc->_table_size = 0;
diff --git a/image/codecs/indeo4.cpp b/image/codecs/indeo4.cpp
index caefab2eab..78eb036159 100644
--- a/image/codecs/indeo4.cpp
+++ b/image/codecs/indeo4.cpp
@@ -624,22 +624,22 @@ int Indeo4Decoder::decodePlaneSubdivision() {
 /**
  *  Indeo 4 8x8 scan (zigzag) patterns
  */
-static const uint8 ivi4_alternate_scan_8x8[64] = {
+static const uint8 ivi4AlternateScan8x8[64] = {
 	0,  8,  1,  9, 16, 24,  2,  3, 17, 25, 10, 11, 32, 40, 48, 56,
 	4,  5,  6,  7, 33, 41, 49, 57, 18, 19, 26, 27, 12, 13, 14, 15,
 	34, 35, 43, 42, 50, 51, 59, 58, 20, 21, 22, 23, 31, 30, 29, 28,
 	36, 37, 38, 39, 47, 46, 45, 44, 52, 53, 54, 55, 63, 62, 61, 60
 };
 
-static const uint8 ivi4_alternate_scan_4x4[16] = {
+static const uint8 ivi4AlternateScan4x4[16] = {
 	0, 1, 4, 5, 8, 12, 2, 3, 9, 13, 6, 7, 10, 11, 14, 15
 };
 
-static const uint8 ivi4_vertical_scan_4x4[16] = {
+static const uint8 ivi4VerticalScan4x4[16] = {
 	0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15
 };
 
-static const uint8 ivi4_horizontal_scan_4x4[16] = {
+static const uint8 ivi4HorizontalScan4x4[16] = {
 	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 };
 
@@ -648,47 +648,47 @@ const uint Indeo4Decoder::_ivi4_common_pic_sizes[14] = {
 };
 
 Indeo4Decoder::Transform Indeo4Decoder::_transforms[18] = {
-	{ IndeoDSP::ff_ivi_inverse_haar_8x8,  IndeoDSP::ff_ivi_dc_haar_2d,       1 },
-	{ IndeoDSP::ff_ivi_row_haar8,         IndeoDSP::ff_ivi_dc_haar_2d,       0 },
-	{ IndeoDSP::ff_ivi_col_haar8,         IndeoDSP::ff_ivi_dc_haar_2d,       0 },
-	{ IndeoDSP::ff_ivi_put_pixels_8x8,    IndeoDSP::ff_ivi_put_dc_pixel_8x8, 1 },
-	{ IndeoDSP::ff_ivi_inverse_slant_8x8, IndeoDSP::ff_ivi_dc_slant_2d,      1 },
-	{ IndeoDSP::ff_ivi_row_slant8,        IndeoDSP::ff_ivi_dc_row_slant,     1 },
-	{ IndeoDSP::ff_ivi_col_slant8,        IndeoDSP::ff_ivi_dc_col_slant,     1 },
+	{ IndeoDSP::ffIviInverseHaar8x8,  IndeoDSP::ffIviDcHaar2d,       1 },
+	{ IndeoDSP::ffIviRowHaar8,         IndeoDSP::ffIviDcHaar2d,       0 },
+	{ IndeoDSP::ffIviColHaar8,         IndeoDSP::ffIviDcHaar2d,       0 },
+	{ IndeoDSP::ffIviPutPixels8x8,    IndeoDSP::ffIviPutDcPixel8x8, 1 },
+	{ IndeoDSP::ffIviInverseSlant8x8, IndeoDSP::ffIviDcSlant2d,      1 },
+	{ IndeoDSP::ffIviRowSlant8,        IndeoDSP::ffIviDcRowSlant,     1 },
+	{ IndeoDSP::ffIviColSlant8,        IndeoDSP::ffIviDcColSlant,     1 },
 	{ NULL, NULL, 0 }, // inverse DCT 8x8
 	{ NULL, NULL, 0 }, // inverse DCT 8x1
 	{ NULL, NULL, 0 }, // inverse DCT 1x8
-	{ IndeoDSP::ff_ivi_inverse_haar_4x4,  IndeoDSP::ff_ivi_dc_haar_2d,       1 },
-	{ IndeoDSP::ff_ivi_inverse_slant_4x4, IndeoDSP::ff_ivi_dc_slant_2d,      1 },
+	{ IndeoDSP::ffIviInverseHaar4x4,  IndeoDSP::ffIviDcHaar2d,       1 },
+	{ IndeoDSP::ffIviInverseSlant4x4, IndeoDSP::ffIviDcSlant2d,      1 },
 	{ NULL, NULL, 0 }, // no transform 4x4
-	{ IndeoDSP::ff_ivi_row_haar4,         IndeoDSP::ff_ivi_dc_haar_2d,       0 },
-	{ IndeoDSP::ff_ivi_col_haar4,         IndeoDSP::ff_ivi_dc_haar_2d,       0 },
-	{ IndeoDSP::ff_ivi_row_slant4,        IndeoDSP::ff_ivi_dc_row_slant,     0 },
-	{ IndeoDSP::ff_ivi_col_slant4,        IndeoDSP::ff_ivi_dc_col_slant,     0 },
+	{ IndeoDSP::ffIviRowHaar4,         IndeoDSP::ffIviDcHaar2d,       0 },
+	{ IndeoDSP::ffIviColHaar4,         IndeoDSP::ffIviDcHaar2d,       0 },
+	{ IndeoDSP::ffIviRowSlant4,        IndeoDSP::ffIviDcRowSlant,     0 },
+	{ IndeoDSP::ffIviColSlant4,        IndeoDSP::ffIviDcColSlant,     0 },
 	{ NULL, NULL, 0 }, // inverse DCT 4x4
 };
 
 const uint8 *const Indeo4Decoder::_scan_index_to_tab[15] = {
 	// for 8x8 transforms
-	ff_zigzag_direct,
-	ivi4_alternate_scan_8x8,
-	_ff_ivi_horizontal_scan_8x8,
-	_ff_ivi_vertical_scan_8x8,
-	ff_zigzag_direct,
+	ffZigZagDirect,
+	ivi4AlternateScan8x8,
+	_ffIviHorizontalScan8x8,
+	_ffIviVerticalScan8x8,
+	ffZigZagDirect,
 
 	// for 4x4 transforms
-	_ff_ivi_direct_scan_4x4,
-	ivi4_alternate_scan_4x4,
-	ivi4_vertical_scan_4x4,
-	ivi4_horizontal_scan_4x4,
-	_ff_ivi_direct_scan_4x4,
+	_ffIviDirectScan4x4,
+	ivi4AlternateScan4x4,
+	ivi4VerticalScan4x4,
+	ivi4HorizontalScan4x4,
+	_ffIviDirectScan4x4,
 
 	// TODO: check if those are needed
-	_ff_ivi_horizontal_scan_8x8,
-	_ff_ivi_horizontal_scan_8x8,
-	_ff_ivi_horizontal_scan_8x8,
-	_ff_ivi_horizontal_scan_8x8,
-	_ff_ivi_horizontal_scan_8x8
+	_ffIviHorizontalScan8x8,
+	_ffIviHorizontalScan8x8,
+	_ffIviHorizontalScan8x8,
+	_ffIviHorizontalScan8x8,
+	_ffIviHorizontalScan8x8
 };
 
 /**
diff --git a/image/codecs/indeo5.cpp b/image/codecs/indeo5.cpp
index 6eacbb80f7..d7bb9d97f6 100644
--- a/image/codecs/indeo5.cpp
+++ b/image/codecs/indeo5.cpp
@@ -425,8 +425,8 @@ int Indeo5Decoder::decode_gop_header() {
 		picConf._picHeight = _ctx._gb->getBits(13);
 		picConf._picWidth = _ctx._gb->getBits(13);
 	} else {
-		picConf._picHeight = _ivi5_common_pic_sizes[picSizeIndx * 2 + 1] << 2;
-		picConf._picWidth = _ivi5_common_pic_sizes[picSizeIndx * 2] << 2;
+		picConf._picHeight = _commonPicSizes[picSizeIndx * 2 + 1] << 2;
+		picConf._picWidth = _commonPicSizes[picSizeIndx * 2] << 2;
 	}
 
 	if (_ctx._gopFlags & 2) {
@@ -485,43 +485,43 @@ int Indeo5Decoder::decode_gop_header() {
 			// select transform function and scan pattern according to plane and band number
 			switch ((p << 2) + i) {
 			case 0:
-				band->_invTransform = IndeoDSP::ff_ivi_inverse_slant_8x8;
-				band->_dcTransform = IndeoDSP::ff_ivi_dc_slant_2d;
-				band->_scan = ff_zigzag_direct;
+				band->_invTransform = IndeoDSP::ffIviInverseSlant8x8;
+				band->_dcTransform = IndeoDSP::ffIviDcSlant2d;
+				band->_scan = ffZigZagDirect;
 				band->_transformSize = 8;
 				break;
 
 			case 1:
-				band->_invTransform = IndeoDSP::ff_ivi_row_slant8;
-				band->_dcTransform = IndeoDSP::ff_ivi_dc_row_slant;
-				band->_scan = _ff_ivi_vertical_scan_8x8;
+				band->_invTransform = IndeoDSP::ffIviRowSlant8;
+				band->_dcTransform = IndeoDSP::ffIviDcRowSlant;
+				band->_scan = _ffIviVerticalScan8x8;
 				band->_transformSize = 8;
 				break;
 
 			case 2:
-				band->_invTransform = IndeoDSP::ff_ivi_col_slant8;
-				band->_dcTransform = IndeoDSP::ff_ivi_dc_col_slant;
-				band->_scan = _ff_ivi_horizontal_scan_8x8;
+				band->_invTransform = IndeoDSP::ffIviColSlant8;
+				band->_dcTransform = IndeoDSP::ffIviDcColSlant;
+				band->_scan = _ffIviHorizontalScan8x8;
 				band->_transformSize = 8;
 				break;
 
 			case 3:
-				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->_invTransform = IndeoDSP::ffIviPutPixels8x8;
+				band->_dcTransform = IndeoDSP::ffIviPutDcPixel8x8;
+				band->_scan = _ffIviHorizontalScan8x8;
 				band->_transformSize = 8;
 				break;
 
 			case 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->_invTransform = IndeoDSP::ffIviInverseSlant4x4;
+				band->_dcTransform = IndeoDSP::ffIviDcSlant2d;
+				band->_scan = _ffIviDirectScan4x4;
 				band->_transformSize = 4;
 				break;
 			}
 
-			band->_is2dTrans = band->_invTransform == IndeoDSP::ff_ivi_inverse_slant_8x8 ||
-				band->_invTransform == IndeoDSP::ff_ivi_inverse_slant_4x4;
+			band->_is2dTrans = band->_invTransform == IndeoDSP::ffIviInverseSlant8x8 ||
+				band->_invTransform == IndeoDSP::ffIviInverseSlant4x4;
 
 			if (band->_transformSize != band->_blkSize) {
 				warning("transform and block size mismatch (%d != %d)", band->_transformSize, band->_blkSize);
@@ -540,15 +540,15 @@ int Indeo5Decoder::decode_gop_header() {
 					warning("_quantMat %d too large!", quantMat);
 					return -1;
 				}
-				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];
+				band->_intraBase = &_baseQuant8x8Intra[quantMat][0];
+				band->_interBase = &_baseQuant8x8Inter[quantMat][0];
+				band->_intraScale = &_scaleQuant8x8Intra[quantMat][0];
+				band->_interScale = &_scaleQuant8x8Inter[quantMat][0];
 			} else {
-				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;
+				band->_intraBase = _baseQuant4x4Intra;
+				band->_interBase = _baseQuant4x4Inter;
+				band->_intraScale = _scaleQuant4x4Intra;
+				band->_interScale = _scaleQuant4x4Inter;
 			}
 
 			if (_ctx._gb->getBits(2)) {
@@ -631,17 +631,12 @@ int Indeo5Decoder::skip_hdr_extension() {
 
 /*------------------------------------------------------------------------*/
 
-const uint8 Indeo5Decoder::_ivi5_common_pic_sizes[30] = {
+const uint8 Indeo5Decoder::_commonPicSizes[30] = {
 	160, 120, 80, 60, 40, 30, 176, 120, 88, 60, 88, 72, 44, 36, 60, 45, 160, 60,
 	176,  60, 20, 15, 22, 18,   0,   0,  0,  0,  0,  0
 };
 
-const uint8 Indeo5Decoder::ivi5_common_pic_sizes[30] = {
-    160, 120, 80, 60, 40, 30, 176, 120, 88, 60, 88, 72, 44, 36, 60, 45, 160, 60,
-    176,  60, 20, 15, 22, 18,   0,   0,  0,  0,  0,  0
-};
-
-const uint16 Indeo5Decoder::_ivi5_base_quant_8x8_inter[5][64] = {
+const uint16 Indeo5Decoder::_baseQuant8x8Inter[5][64] = {
     {0x26, 0x3a, 0x3e, 0x46, 0x4a, 0x4e, 0x52, 0x5a, 0x3a, 0x3e, 0x42, 0x46, 0x4a, 0x4e, 0x56, 0x5e,
      0x3e, 0x42, 0x46, 0x48, 0x4c, 0x52, 0x5a, 0x62, 0x46, 0x46, 0x48, 0x4a, 0x4e, 0x56, 0x5e, 0x66,
      0x4a, 0x4a, 0x4c, 0x4e, 0x52, 0x5a, 0x62, 0x6a, 0x4e, 0x4e, 0x52, 0x56, 0x5a, 0x5e, 0x66, 0x6e,
@@ -669,7 +664,7 @@ const uint16 Indeo5Decoder::_ivi5_base_quant_8x8_inter[5][64] = {
     }
 };
 
-const uint16 Indeo5Decoder::_ivi5_base_quant_8x8_intra[5][64] = {
+const uint16 Indeo5Decoder::_baseQuant8x8Intra[5][64] = {
     {0x1a, 0x2e, 0x36, 0x42, 0x46, 0x4a, 0x4e, 0x5a, 0x2e, 0x32, 0x3e, 0x42, 0x46, 0x4e, 0x56, 0x6a,
      0x36, 0x3e, 0x3e, 0x44, 0x4a, 0x54, 0x66, 0x72, 0x42, 0x42, 0x44, 0x4a, 0x52, 0x62, 0x6c, 0x7a,
      0x46, 0x46, 0x4a, 0x52, 0x5e, 0x66, 0x72, 0x8e, 0x4a, 0x4e, 0x54, 0x62, 0x66, 0x6e, 0x86, 0xa6,
@@ -697,16 +692,16 @@ const uint16 Indeo5Decoder::_ivi5_base_quant_8x8_intra[5][64] = {
     }
 };
 
-const uint16 Indeo5Decoder::_ivi5_base_quant_4x4_inter[16] = {
+const uint16 Indeo5Decoder::_baseQuant4x4Inter[16] = {
     0x1e, 0x3e, 0x4a, 0x52, 0x3e, 0x4a, 0x52, 0x56, 0x4a, 0x52, 0x56, 0x5e, 0x52, 0x56, 0x5e, 0x66
 };
 
-const uint16 Indeo5Decoder::_ivi5_base_quant_4x4_intra[16] = {
+const uint16 Indeo5Decoder::_baseQuant4x4Intra[16] = {
     0x1e, 0x3e, 0x4a, 0x52, 0x3e, 0x4a, 0x52, 0x5e, 0x4a, 0x52, 0x5e, 0x7a, 0x52, 0x5e, 0x7a, 0x92
 };
 
 
-const uint8 Indeo5Decoder::_ivi5_scale_quant_8x8_inter[5][24] = {
+const uint8 Indeo5Decoder::_scaleQuant8x8Inter[5][24] = {
     {0x0b, 0x11, 0x13, 0x14, 0x15, 0x16, 0x18, 0x1a, 0x1b, 0x1d, 0x20, 0x22,
      0x23, 0x25, 0x28, 0x2a, 0x2e, 0x32, 0x35, 0x39, 0x3d, 0x41, 0x44, 0x4a,
     },
@@ -724,7 +719,7 @@ const uint8 Indeo5Decoder::_ivi5_scale_quant_8x8_inter[5][24] = {
     },
 };
 
-const uint8 Indeo5Decoder::_ivi5_scale_quant_8x8_intra[5][24] = {
+const uint8 Indeo5Decoder::_scaleQuant8x8Intra[5][24] = {
     {0x0b, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x17, 0x18, 0x1a, 0x1c, 0x1e, 0x20,
      0x22, 0x24, 0x27, 0x28, 0x2a, 0x2d, 0x2f, 0x31, 0x34, 0x37, 0x39, 0x3c,
     },
@@ -742,12 +737,12 @@ const uint8 Indeo5Decoder::_ivi5_scale_quant_8x8_intra[5][24] = {
     }
 };
 
-const uint8 Indeo5Decoder::_ivi5_scale_quant_4x4_inter[24] = {
+const uint8 Indeo5Decoder::_scaleQuant4x4Inter[24] = {
     0x0b, 0x0d, 0x0d, 0x0e, 0x11, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
 };
 
-const uint8 Indeo5Decoder::_ivi5_scale_quant_4x4_intra[24] = {
+const uint8 Indeo5Decoder::_scaleQuant4x4Intra[24] = {
     0x01, 0x0b, 0x0b, 0x0d, 0x0d, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x13, 0x14,
     0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20
 };
diff --git a/image/codecs/indeo5.h b/image/codecs/indeo5.h
index 9832967d5d..169bef9794 100644
--- a/image/codecs/indeo5.h
+++ b/image/codecs/indeo5.h
@@ -112,12 +112,7 @@ private:
 	/**
 	 *  standard picture dimensions (width, height divided by 4)
 	 */
-	static const uint8 _ivi5_common_pic_sizes[30];
-
-	/**
-	 *  standard picture dimensions (width, height divided by 4)
-	 */
-	static const uint8 ivi5_common_pic_sizes[30];
+	static const uint8 _commonPicSizes[30];
 
 	/**
 	 *  Indeo5 dequantization matrixes consist of two tables: base table
@@ -128,17 +123,17 @@ private:
 	 *  ivi5_base_quant_bbb_ttt  - base  tables for block size 'bbb' of type 'ttt'
 	 *  ivi5_scale_quant_bbb_ttt - scale tables for block size 'bbb' of type 'ttt'
 	 */
-	static const uint16 _ivi5_base_quant_8x8_inter[5][64];
-	static const uint16 _ivi5_base_quant_8x8_intra[5][64];
+	static const uint16 _baseQuant8x8Inter[5][64];
+	static const uint16 _baseQuant8x8Intra[5][64];
 
-	static const uint16 _ivi5_base_quant_4x4_inter[16];
-	static const uint16 _ivi5_base_quant_4x4_intra[16];
+	static const uint16 _baseQuant4x4Inter[16];
+	static const uint16 _baseQuant4x4Intra[16];
 
-	static const uint8 _ivi5_scale_quant_8x8_inter[5][24];
-	static const uint8 _ivi5_scale_quant_8x8_intra[5][24];
+	static const uint8 _scaleQuant8x8Inter[5][24];
+	static const uint8 _scaleQuant8x8Intra[5][24];
 
-	static const uint8 _ivi5_scale_quant_4x4_inter[24];
-	static const uint8 _ivi5_scale_quant_4x4_intra[24];
+	static const uint8 _scaleQuant4x4Inter[24];
+	static const uint8 _scaleQuant4x4Intra[24];
 };
 
 } // End of namespace Image