|
|
/* *************************************************************************
** INTEL Corporation Proprietary Information**** This listing is supplied under the terms of a license** agreement with INTEL Corporation and may not be copied** nor disclosed except in accordance with the terms of** that agreement.**** Copyright (c) 1995 Intel Corporation.** All Rights Reserved.**** **************************************************************************/
////////////////////////////////////////////////////////////////////////////
// $Header: S:\h26x\src\dec\dxap.cpv 1.4 20 Oct 1996 13:22:12 AGUPTA2 $
//
// $Log: S:\h26x\src\dec\dxap.cpv $
//
// Rev 1.4 20 Oct 1996 13:22:12 AGUPTA2
// Changed DBOUT into DbgLog. ASSERT is not changed to DbgAssert.
//
//
// Rev 1.3 27 Aug 1996 11:20:06 KLILLEVO
// changed GlobalAlloc/GLobalLock to HeapAlloc
//
// Rev 1.2 27 Dec 1995 14:36:10 RMCKENZX
// Added copyright notice
//
// Rev 1.1 10 Nov 1995 14:45:02 CZHU
//
//
// Rev 1.0 10 Nov 1995 13:54:28 CZHU
// Initial revision.
#include "precomp.h"
#ifdef TRACK_ALLOCATIONS
char gsz1[32];char gsz2[32];char gsz3[32];char gsz4[32];char gsz5[32];#endif
U8 gUTable[256] ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,130,130,130,130,130,130,130,130,130,130,130,130,130,130,130,130,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170};
U8 gVTable[256]={ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,68,68,68,68,68,68,68,68,68,68,68,68,68,68,68,68,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85
};
/***************************************************************************
* ComputeDymanicClut() computes the clut tables on the fly, based on the * * current palette[]; * * called from InitColorConvertor, when CLUTAP is selected * ***************************************************************************/LRESULT ComputeDynamicClutNew(U8 *pAPTable, U8 *pActivePalette, int iPalSize){
/*
* The dynamic clut consists of 4 entries which MUST be * contiguous in memory: * * ClutTable: 65536 1-byte entries * Each entry is the closest pPalette entry, as * indexed by a 14 bit value: uvuvuvuv0yyyyyyy, * dithered * * TableU: 256 4-byte entries * Each entry is u0u0u0u0:u0u0u0u0:u0u0u0u0:u0u0u0u0, * each uuuu is a 4 bit dithered u value for the * index, which is a u value in the range 8-120 * * TableV: 256 4-byte entries * Same as TableU, except the values are arranged * 0v0v0v0v:0v0v0v0v:0v0v0v0v:0v0v0v0v. */
Color *pPalette; U8 *pTmpPtr; U8 pYSlice[YSIZ][256], *pYYPtr; I32 *pYCnt; U32 *pDiff, *dptr, *delta, *deptr; I32 i,j,yseg,y,u,v,mini,yo,uo,vo,ycount,yi; U32 addr1,addr2,ind; U32 d,min; // since 3*128^2 = 49K
PALETTEENTRY *lpPal, *palptr; Color *colptr; I32 Y, U, V; I32 U_0, U_1, U_2, U_3; I32 V_0, V_1, V_2, V_3; I32 Umag, Vmag; /* dist max is 128*128*3 = 49152 */ U32 dist; U32 close_dist[MAG_NUM_NEAREST]; I32 palindex; I32 R, G, B; I32 k, p, tmp, iu, iv; /* Ubias and Vbias max is (128 * 4 * BIAS_PAL_SAMPLES) = 65536 */ /* even the worst palette (all black except the reserved colors) */ /* would not achieve this. */ I32 Ubias, Vbias; U32 Udither, Vdither; U32 *TableUptr, *TableVptr;
FX_ENTRY("ComputeDynamicClutNew")
DEBUGMSG(ZONE_DECODE_DETAILS, ("%s: ComputeDynamic CLUT8 index tables\r\n", _fx_));
/* allocate some memory */ pPalette = (Color *)HeapAlloc(GetProcessHeap(), NULL, sizeof(Color)*256);
#ifdef TRACK_ALLOCATIONS
// Track memory allocation
wsprintf(gsz1, "DXAP: %7ld Ln %5ld\0", sizeof(Color)*256, __LINE__); AddName((unsigned int)pPalette, gsz1);#endif
pYCnt = (I32 *) HeapAlloc(GetProcessHeap(), NULL, sizeof(I32) *YSIZ);
#ifdef TRACK_ALLOCATIONS
// Track memory allocation
wsprintf(gsz2, "DXAP: %7ld Ln %5ld\0", sizeof(I32) *YSIZ, __LINE__); AddName((unsigned int)pYCnt, gsz2);#endif
pDiff = (U32 *) HeapAlloc(GetProcessHeap(), NULL, sizeof(U32) *256);
#ifdef TRACK_ALLOCATIONS
// Track memory allocation
wsprintf(gsz3, "DXAP: %7ld Ln %5ld\0", sizeof(U32) *256, __LINE__); AddName((unsigned int)pDiff, gsz3);#endif
delta = (U32 *) HeapAlloc(GetProcessHeap(), NULL, sizeof(U32) *256);
#ifdef TRACK_ALLOCATIONS
// Track memory allocation
wsprintf(gsz4, "DXAP: %7ld Ln %5ld\0", sizeof(U32) *256, __LINE__); AddName((unsigned int)delta, gsz4);#endif
lpPal = (PALETTEENTRY *)HeapAlloc(GetProcessHeap(), NULL, sizeof(PALETTEENTRY)*256);
#ifdef TRACK_ALLOCATIONS
// Track memory allocation
wsprintf(gsz5, "DXAP: %7ld Ln %5ld\0", sizeof(PALETTEENTRY)*256, __LINE__); AddName((unsigned int)lpPal, gsz5);#endif
if (!pPalette || !pYCnt || !pDiff || !delta || !lpPal) return (ICERR_MEMORY);
for (i=-256; i<256; i++) squares[256+i] = i*i;
memcpy((U8 *)lpPal, pActivePalette, iPalSize);
palptr = lpPal; colptr = pPalette; for (i = 0; i < 256; i++) { /* In BGR (RGBQuad) order. */ B = palptr->peRed; G = palptr->peGreen; R = palptr->peBlue; colptr->y = YFROM(R, G, B); colptr->u = UFROM(R, G, B); colptr->v = VFROM(R, G, B); palptr++; colptr++; }
for (i=0; i<YSIZ; i++) pYCnt[i] = 0;
for (i=0; i<256; i++) { yseg = pPalette[i].y >> 4; pYSlice[yseg][ pYCnt[yseg]++ ] = (U8) i; }
// Do exhaustive search on all U,V points and a coarse grid in Y
for (u=0; u<256; u+=UVSTEP) { for (v=0; v<256; v+=UVSTEP) { ind = TBLIDX(0,u,v); pTmpPtr = pAPTable+ind; for (y=0; y<256; y+=YSTEP) { colptr = pPalette; min = 0x0FFFFFFF; for (i=0; i<NCOL; i++, colptr++) { d = (3*squares[256+y - colptr->y])>>1; if (d > min) continue; d += squares[256+u - colptr->u]; if (d > min) continue;
d += squares[256+v - colptr->v]; if (d < min) { min = d; mini = i; } } *pTmpPtr = (U8) mini; pTmpPtr += YSTEP;
} } }#ifdef STATISTICS
#if defined USE_STAT_BOARD
dwStopTime = ReadElapsed()>>2;#else
dwStopTime = bentime();#endif /* USE_STAT_BOARD */
dwElapsedTime = dwStopTime - dwStartTime2 - dwOverheadTime; DPF("CoarseSearch() time = %lu microseconds",dwElapsedTime);#endif
// Go thru points not yet done, and search
// (1) The closest point to the prev and next Y in coarse grid
// (2) All the points in this Y slice
//
// Also, take advantage of the fact that we can do distance computation
// incrementally. Keep all N errors in an array, and update each
// time we change Y.
for (u=0; u<256; u+=UVSTEP) { for (v=0; v<256; v+=UVSTEP) { for (y=YGAP; y<256; y+=YSTEP) { yseg = y >> 4; ycount = pYCnt[yseg] + 2; // +2 is 'cause we add 2 Y endpoints
pYYPtr = (U8 *)pYSlice[yseg]; addr1 = TBLIDX(yseg*16,u,v); pYYPtr[ycount-2] = *(U8 *)(pAPTable +addr1);
addr2 = TBLIDX((yseg+(yseg < (YSIZ -1)))*16,u,v); pYYPtr[ycount-1] = *(U8 *)(pAPTable +addr2);
dptr = pDiff; deptr = delta; for (i=0; i<ycount; i++, pYYPtr++, dptr++, deptr++) { j = *pYYPtr; /* pYSlice[yseg][i]; */ colptr = pPalette+j; yo = colptr->y; uo = colptr->u; vo = colptr->v; *dptr = ( 3*squares[256+y-yo] + 2*(squares[256+u-uo] + squares[256+v-vo])); *deptr =( 3*(((y-yo)<<1) + 1)); }
ind = TBLIDX(y,u,v); pTmpPtr = pAPTable+ind; for (yi=0; yi<YSTEP-1; yi += YGAP) { min = 0x0FFFFFFF; pYYPtr = (U8 *)pYSlice[yseg]; dptr = pDiff; deptr = delta; for (i=0; i<ycount; i++, pYYPtr++, dptr++, deptr++) { if (*dptr < min) { min = *dptr; mini = *pYYPtr; /* pYSlice[yseg][i]; */ } *dptr += *deptr; *deptr += 6; } *pTmpPtr = (U8) mini; pTmpPtr++;
} } } }
/* now do U and V dither tables and shift lookup table*/ /* NOTE: All Y, U, V values are 7 bits */
Umag = Vmag = 0; Ubias = Vbias = 0;
/* use srand(0) and rand() to generate a repeatable series of */ /* pseudo-random numbers */ srand((unsigned)1); for (p = 0; p < MAG_PAL_SAMPLES; ++p) // 32
{ for (i = 0; i < MAG_NUM_NEAREST; ++i) // 6
{ close_dist[i] = 0x7FFFL; } palindex = RANDOM(235) + 10; /* random palette index, unreserved colors */ colptr = &pPalette[palindex]; Y = colptr->y; U = colptr->u; V = colptr->v; colptr = pPalette; for (i = 0; i < 255; ++i) { if (i != palindex) { dist = squares[256+(Y - colptr->y)] + squares[256+(U - colptr->u)] + squares[256+(V - colptr->v)]; /* keep a sorted list of the nearest MAG_NUM_NEAREST entries */ for (j = 0; j < MAG_NUM_NEAREST; ++j) //6
{ if (dist < close_dist[j]) { /* insert new entry; shift others down */ for (k = (MAG_NUM_NEAREST-1); k > j; k--) { close_dist[k] = close_dist[k-1]; } close_dist[j] = dist; break; /* out of for j loop */ } } /* for j */ } /* if i */ ++colptr; } /* for i */ /* now calculate Umag as the average of (U - U[1-6]) */ /* calculate Vmag in the same way */ for (i = 0; i < MAG_NUM_NEAREST; ++i) { /* there are (MAG_PAL_SAMPLES * MAG_NUM_NEAREST) sqrt() */ /* calls in this method */ Umag += (I32)sqrt((double)close_dist[i]); } } /* for p */
Umag /= (MAG_NUM_NEAREST * MAG_PAL_SAMPLES); Vmag = Umag; for (p = 0; p < BIAS_PAL_SAMPLES; ++p) //132
{
/* now calculate the average bias (use random RGB points) */ R = RANDOM(255); G = RANDOM(255); B = RANDOM(255); Y = YFROM(R, G, B); U = UFROM(R, G, B); V = VFROM(R, G, B); for (d = 0; d < 4; d++) { U_0 = U + (dither[d].Udither*Umag)/3; V_0 = V + (dither[d].Vdither*Vmag)/3; /* Clamp values */ if (U_0 > 255) U_0 = 255; if (V_0 > 255) V_0 = 255; /* (Y, U_0, V_0) is the dithered YUV for the RGB point */ /* colptr points to the closest palette entry to the dithered */ /* RGB */ /* colptr = &pPalette[pAPTable[TBLIDX(Y, U_0+(UVSTEP>>1), V_0+(UVSTEP>>1))]]; */ pTmpPtr= (U8 *)(pAPTable + (U32)TBLIDX(Y, U_0, V_0)) ; palindex=*pTmpPtr; colptr = &pPalette[palindex]; Ubias += (U - colptr->u); Vbias += (V - colptr->v); } } /* for p */ Ubias =(I32) (Ubias+BIAS_PAL_SAMPLES*2)/(I32)(BIAS_PAL_SAMPLES * 4); Vbias =(I32) (Vbias+BIAS_PAL_SAMPLES*2)/(I32)(BIAS_PAL_SAMPLES * 4);
U_0 = (2*(I32)Umag/3); V_0 = (1*(I32)Vmag/3); U_1 = (1*(I32)Umag/3); V_1 = (2*(I32)Vmag/3); U_2 = (0*(I32)Umag/3); V_2 = (3*(I32)Vmag/3); U_3 = (3*(I32)Umag/3); V_3 = (0*(I32)Vmag/3);
TableUptr = (U32 *)(pAPTable+ (U32)65536L); TableVptr = TableUptr + 256; iu = Ubias /* + (UVSTEP>>1) */; iv = Vbias /* + (UVSTEP>>1) */;
for (i = 0; i < 256; i++, iu++, iv++) { /* dither: u0u0u0u0, 0v0v0v0v */ tmp = iu + U_0; Udither = gUTable[CLAMP8(tmp)]; Udither <<= 8; tmp = iu + U_1; Udither |= gUTable[CLAMP8(tmp)]; Udither <<= 8; tmp = iu ; Udither |= gUTable[CLAMP8(tmp)]; Udither <<= 8; tmp = iu + U_3; Udither |= gUTable[CLAMP8(tmp)]; *TableUptr++ = Udither ; tmp = iv + V_0; Vdither = gVTable[CLAMP8(tmp)]; Vdither <<= 8; tmp = iv + V_1; Vdither |= gVTable[CLAMP8(tmp)]; Vdither <<= 8; tmp = iv + V_2; Vdither |= gVTable[CLAMP8(tmp)]; Vdither <<= 8; tmp = iv ; Vdither |= gVTable[CLAMP8(tmp)]; /* V_3 == 0 */ *TableVptr++ = Vdither;
}
//adjust color for 0--8 and 120-128 for luma
// 0--16, 241-255 plus dither for chroma
TableUptr = (U32 *)(pAPTable+ (U32)65536L); TableVptr = TableUptr + 256; for (i=0; i<16;i++) { TableUptr[i]= TableUptr[16]; TableVptr[i]= TableVptr[16]; }
for (i=241;i<256;i++) { TableUptr[i]= TableUptr[240]; TableVptr[i]= TableVptr[240]; }
for (u = 0; u < 256; u += UVSTEP) { for (v = 0; v < 256; v += UVSTEP) { pTmpPtr= (U8 *)(pAPTable + (U32)TBLIDX(16, u, v)) ; mini = *pTmpPtr;
for (y = Y_DITHER_MIN; y < 16; y += 2) { pTmpPtr--; *pTmpPtr = (U8)mini; }
pTmpPtr= (U8 *)(pAPTable + (U32)TBLIDX(240, u, v)) ; mini = *pTmpPtr;
for (y = 241; y < 256+Y_DITHER_MAX; y +=2) { pTmpPtr++; *pTmpPtr = (U8)mini; } } /* for v... */ } /* for u... */
/* free memory allocated */ HeapFree(GetProcessHeap(), NULL, pPalette);#ifdef TRACK_ALLOCATIONS
// Track memory allocation
RemoveName((unsigned int)pPalette);#endif
HeapFree(GetProcessHeap(), NULL, pYCnt);#ifdef TRACK_ALLOCATIONS
// Track memory allocation
RemoveName((unsigned int)pYCnt);#endif
HeapFree(GetProcessHeap(), NULL, pDiff);#ifdef TRACK_ALLOCATIONS
// Track memory allocation
RemoveName((unsigned int)pDiff);#endif
HeapFree(GetProcessHeap(), NULL, delta);#ifdef TRACK_ALLOCATIONS
// Track memory allocation
RemoveName((unsigned int)delta);#endif
HeapFree(GetProcessHeap(), NULL, lpPal);#ifdef TRACK_ALLOCATIONS
// Track memory allocation
RemoveName((unsigned int)lpPal);#endif
return (ICERR_OK);
}
|
