gif.cpp.svn-base

gif to bmp conversion

error :
	if (phPrefix != JC_NULL)
	{
		jdd_MemFree (phPrefix) ;
	}
	if (pucSuffix != JC_NULL)
	{
		jdd_MemFree (pucSuffix) ;
	}
	if (pucOutStack != JC_NULL)
	{
		jdd_MemFree (pucOutStack) ;
	}
	
	if (cError_flag == 1)
	{
		return 0 ;
	}

	jdd_MemFree(stFileMgr.pucBuf);

    return iwhichBit;
}

JC_INT32 GifGetLong (JC_INT8 *buf)
{
	JC_INT32 lval = 0 ;

	lval = (buf [3] & 0xFF) ;
	lval = (lval << 8) | (buf [2] & 0xFF) ;
	lval = (lval << 8) | (buf [1] & 0xFF) ; 
	lval = (lval << 8) | (buf [0] & 0xFF) ; 
	return lval ;
}

JC_INT32	GifFrameInit( ST_FRAME_ATTRIBUTE* pstFrameAttribute, JC_INT32 iWidth, JC_INT32 iHeight) 
{
	JC_RETCODE     rCode = E_TRUE; 
	if( JC_NULL != pstFrameAttribute)
	{
		JC_INT32	*pMask		= (JC_INT32 *)JC_NULL ;
		JC_UINT8	*pRaster ;

		jc_memset(pstFrameAttribute, 0x00, sizeof(ST_FRAME_ATTRIBUTE)) ;
		pstFrameAttribute->iFrameWidth	= iWidth ;
		pstFrameAttribute->iFrameHeight	= iHeight ;
   		pstFrameAttribute->iFrameStride	= iWidth;
		pstFrameAttribute->stPosition.iX	= 0 ;
		pstFrameAttribute->stPosition.iY	= 0 ;
		pstFrameAttribute->iFrameDelay	= 0 ;
		
		pRaster = (JC_UINT8 *) jdd_MemAlloc( sizeof(JC_INT8),(pstFrameAttribute->iFrameStride * iHeight));
		if (!pRaster)
		{
				rCode = E_FALSE ;
		}
		else
		{
		   pstFrameAttribute->pucFrameRaster = pRaster ;
		}
	 }	
	else
	{
		rCode =  E_FALSE ;
	}
	return rCode ;
}

JC_INT32 GifAddFrame (ST_GIF_ATTRIBUTE* pstGifAttribute, ST_FRAME_ATTRIBUTE* pstFrameAttribute)
{
    JC_INT32 iNum ;
    ST_FRAME_ATTRIBUTE **ppstFrameAttribute ;
	JC_RETCODE     rCode = E_TRUE; 

    if( JC_NULL != pstGifAttribute && JC_NULL != pstFrameAttribute)
	{		
		ppstFrameAttribute = (ST_FRAME_ATTRIBUTE **) jdd_MemAlloc(  sizeof(ST_FRAME_ATTRIBUTE),pstGifAttribute->iFrameCount + 1) ;
		if (ppstFrameAttribute)
		{
			for (iNum=0 ; iNum < pstGifAttribute->iFrameCount; iNum++) 
				ppstFrameAttribute[iNum] = pstGifAttribute->ppstFrameAttribute[iNum ];

			if (pstGifAttribute->ppstFrameAttribute != JC_NULL)
			   jdd_MemFree(pstGifAttribute->ppstFrameAttribute);

			pstGifAttribute->ppstFrameAttribute		= ppstFrameAttribute ;
			pstGifAttribute->ppstFrameAttribute[iNum]	= pstFrameAttribute ;
			pstGifAttribute->iFrameCount++ ;
		}
		else
		{
			rCode = E_FALSE;
		}
	}
	else
	{
		rCode = E_FALSE ;
	}

	return rCode ;
}

void GifConvertRGBtoRGBA(unsigned char* pRGB, unsigned char* pRGBA, JC_INT32 iNumColor)
{
	JC_INT32  iI;

	for(iI = 0; iI < iNumColor; iI++)
	{
		//Copy RGB
		*pRGBA++ = *(pRGB + 2);
		*pRGBA++ = *(pRGB + 1);
		*pRGBA++ = *pRGB;
		
		pRGBA++;
		pRGB = pRGB + 3;
	}
}


JC_RETCODE GifGetLongEx(ST_LZW_MGR* pBufMgr, JC_INT32 iIndex, JC_INT32* pLong)
{
	JC_INT32  iOffset;
	JC_INT32  iCorrectedIndex;
    
	iOffset = 0;
	if (!pBufMgr->pucBuf)
	{
		 GifLoadLZWBuffer(pBufMgr,  iOffset); 
	}

	iCorrectedIndex = iIndex - pBufMgr->iStartIndex;
	if(iCorrectedIndex == LZW_BUFFER_SIZE)
	{
		GifLoadLZWBuffer(pBufMgr, 0); 
		pBufMgr->iStartIndex = pBufMgr->iStartIndex + LZW_BUFFER_SIZE;
		iCorrectedIndex = 0; 
	}
    else if (iCorrectedIndex > (LZW_BUFFER_SIZE - 4))
	{
		iOffset = LZW_BUFFER_SIZE -  iCorrectedIndex ;
        GifLoadLZWBuffer(pBufMgr, iOffset); 
		pBufMgr->iStartIndex = pBufMgr->iStartIndex + LZW_BUFFER_SIZE - iOffset;
		iCorrectedIndex = 0; 
	}
    
	jc_memcpy(pLong, pBufMgr->pucBuf + iCorrectedIndex , 4);

	return JC_OK;
}

JC_RETCODE GifLoadLZWBuffer(ST_LZW_MGR* pBufMgr, JC_INT32 iOffset)
{   
	JC_UINT8 ucChunkSize;
	JC_INT32 iRead;
    JC_INT32 iLeftOver;
	JC_UINT8 *pBuf;

	if(!pBufMgr->pucBuf)
	{
		pBufMgr->pucBuf = (JC_UINT8 *)jdd_MemAlloc(1,LZW_BUFFER_SIZE);
	}

	pBuf		= pBufMgr->pucBuf;
	iLeftOver   = LZW_BUFFER_SIZE;
	
	if (iOffset != 0)
	{
		//jdi_GifSkipBytes(pBufMgr->vFilePointer, -iOffset);
		jdd_FSSeek(pBufMgr->vFilePointer, -iOffset, E_FILE_SEEK_CUR);
		pBufMgr->iLeftOverBlockSize = pBufMgr->iLeftOverBlockSize + iOffset;
	}
	
	if (pBufMgr->iLeftOverBlockSize > 0)
	{
		iRead = jdd_FSRead(pBuf, 1,  pBufMgr->iLeftOverBlockSize, pBufMgr->vFilePointer);
        pBuf = pBuf + iRead;
        iLeftOver = iLeftOver - iRead;
	}
	
	/*Read the current chunk size*/
	jdd_FSRead(&ucChunkSize, 1, 1, pBufMgr->vFilePointer);

    while (ucChunkSize)
    {
        iRead =  jdd_FSRead(pBuf, 1, MIN_VALUE(ucChunkSize, iLeftOver), pBufMgr->vFilePointer);
      	pBuf  = pBuf + iRead;
      	iLeftOver = iLeftOver- iRead;
		pBufMgr->iLeftOverBlockSize = ucChunkSize - iRead;

      	if (iRead < ucChunkSize)
		{
      	   break;
		}

   		jdd_FSRead((JC_UINT8 *)&ucChunkSize, 1, 1, pBufMgr->vFilePointer);
    }

	return JC_OK;
}

/***************************************************************************
 * All Global Function Definitions
 **************************************************************************/

/**
  * @brief      	initialises the ST_GIF_ATTRIBUTE structure 
  * @param[in]  	pszGifFile pointer to the source gif file  
  * @param[in]  	pstGifAttribute pointer to the ST_GIF_ATTRIBUTE structure which is 
  *                 initialised in this function 
  * @retval			JC_OK on success
  * @retval			JC_ERR_IMG_FORMAT on error
  * @retval			JC_ERR_FILE_OPEN on error
  */
JC_RETCODE jdi_GifDecodeFile(JC_CHAR* pszGifFile, ST_GIF_ATTRIBUTE* pstGifAttribute)
{
	JC_BOOLEAN				         bRet;
	JC_UINT8				         ucChunkSize;
	JC_UINT8				         ucCharGot;
	JC_INT16			             hFirstbyte = 0 ;
    JC_INT32				         iNum = 0, iGrapExt, iNumGlobalBPP;
	JC_INT32				         iLocalColorMap;  
	JC_INT32				         iLocalColorMapSize = 0, iWidth = 0, iHeight = 0;
	JC_INT32				         iFramePallete ;
    JC_UINT16                        uhCounter = 1;
	ST_GIF_GRAPHICCTRL_EXT           stGifGce;
	ST_GIF_LOGICALSCREEN_DESCRIPTOR  stGifLsd;
	ST_GIF_IMAGE_DISCRIPTOR          stGifId;
	ST_FRAME_ATTRIBUTE*			     lpNextFrame ;
	JC_UINT8*					     pucColorMap;
	JC_UINT8*					     pucRGBAGlobal;
	JC_UINT8*					     pucRGBALocal;
	JDD_FILE		                 vFilePtr ;
	JC_UINT8				         aucSzSignature[6];
	JDD_FSHANDLE	                 fsHandle = JC_NULL ;
   	JC_RETCODE	                     rCode = JC_OK ;
	jdd_FSInitialize (&fsHandle) ;
	vFilePtr = jdd_FSOpen(fsHandle, pszGifFile, E_OPEN_READ_MODE);
	if (JC_NULL != vFilePtr)
	{
		jdd_FSRead(aucSzSignature, 1, 6, vFilePtr);
		if (jc_memcmp (aucSzSignature, "GIF", 3) == 0)
		{ 
			/*Read logical screen descriptor*/
			jdd_FSRead((JC_UINT8 *)&stGifLsd, 1, GIF_LSCREEN_DESCRIPTOR, vFilePtr);
			iNumGlobalBPP = (stGifLsd.ucPackedFields & 0x07) + 1 ;

			pstGifAttribute->iNoFrameLoops	= 0;
			if (stGifLsd.ucPackedFields & 0x80)
			{
				 pucColorMap = (JC_UINT8*) jdd_MemAlloc(3 * (1 << iNumGlobalBPP), sizeof(JC_UINT8));
				 jdd_FSRead(pucColorMap, 1, 3 * (1 << iNumGlobalBPP), vFilePtr);
				 pucRGBAGlobal = (JC_UINT8*) jdd_MemAlloc(4 * (1 << iNumGlobalBPP), sizeof(JC_UINT8));
				 GifConvertRGBtoRGBA( pucColorMap, pucRGBAGlobal, 1 << iNumGlobalBPP);
				 iGrapExt = E_FALSE ;

				 pstGifAttribute->pucGlobalPalette = pucRGBAGlobal;
			}

			do
			{
				  if(!jdd_FSRead((JC_UINT8 *)&ucCharGot, 1, 1, vFilePtr))
					break;

				if (ucCharGot == 0x21)       
				{
					jdd_FSRead((JC_UINT8 *)&ucCharGot, 1, 1, vFilePtr);
					switch (ucCharGot) 
					{
						case 0xF9:  
							jdd_FSRead((JC_UINT8 *)&stGifGce, 1,  GIF_GRAPHICCTRL_EXT, vFilePtr);
							iGrapExt = E_TRUE;
							//jdi_GifSkipBytes(vFilePtr, 1);
							jdd_FSSeek(vFilePtr, 1, E_FILE_SEEK_CUR);
							break;

						case 0xFE:          
						case 0x01:          
						case 0xFF:          
						default:            
							jdd_FSRead(&ucChunkSize, 1,  1, vFilePtr);
							while (ucChunkSize)
							{
								 //jdi_GifSkipBytes(vFilePtr, ucChunkSize);
								 jdd_FSSeek(vFilePtr, ucChunkSize, E_FILE_SEEK_CUR);
								 jdd_FSRead(&ucChunkSize, 1,  1, vFilePtr);
							}

							break;
					}
				 }
				 else if (ucCharGot == 0x2c) 
				 {
					lpNextFrame = (ST_FRAME_ATTRIBUTE*)jdd_MemAlloc ( sizeof(ST_FRAME_ATTRIBUTE),1);
					if (!lpNextFrame)
						break ;

					lpNextFrame->pucFrameRaster	= (JC_UINT8 *)JC_NULL; 
					lpNextFrame->pucFramePalette	= (JC_UINT8 *)JC_NULL; 
		            
   					jdd_FSRead((JC_UINT8 *)&stGifId, 1, GIF_IMAGE_DISCRIPTOR, vFilePtr);

					/*ucPtr = ucPtr + sizeof (stGifId) ;*/
					iLocalColorMap = (stGifId.ucPackedFields & 0x80)? 1 : 0;

					iWidth	= stGifId.uhWidth + stGifId.uhXPos ;
					iHeight	= stGifId.uhHeight + stGifId.uhYPos ;
					
					pstGifAttribute->iScreenWidth	=  MAX_VALUE(pstGifAttribute->iScreenWidth, iWidth) ;
					pstGifAttribute->iScreenHeight	=  MAX_VALUE(pstGifAttribute->iScreenHeight, iHeight) ;
					
					iFramePallete  = iLocalColorMap ? (stGifId.ucPackedFields&7)+1 : iNumGlobalBPP ;
					if (!GifFrameInit ( lpNextFrame, stGifId.uhWidth, stGifId.uhHeight))
						break ;

					lpNextFrame->stPosition.iX	= stGifId.uhXPos;
					lpNextFrame->stPosition.iY	= stGifId.uhYPos;
					
					iLocalColorMapSize = 0;

				 if (iGrapExt)
					{
						lpNextFrame->iFrameTransparent	= (stGifGce.ucPackedFields&0x01) ? stGifGce.ucTransparent : -1; //arun: was -1
						lpNextFrame->iFrameDisposal		= (stGifGce.ucPackedFields & 0x1c) >> 2 ; // Balaji
						lpNextFrame->iFrameTransparency	= (stGifGce.ucPackedFields&0x01) ? 1 : 0;
						lpNextFrame->iFrameDelay			= stGifGce.uhDelay * 10;
						if(lpNextFrame->iFrameDelay < GIF_DEFAULT_MIN_DELAY)
								lpNextFrame->iFrameDelay = GIF_DEFAULT_MIN_DELAY;
						iLocalColorMapSize				= stGifId.ucPackedFields & 0x7;
					}
				
				   if (iLocalColorMap)     
					{
						
						jdd_FSRead(pucColorMap, 1,  3 * (1 << iFramePallete), vFilePtr);
						pucRGBALocal = (unsigned char *)jdd_MemAlloc(4 * (1 << iFramePallete), sizeof(unsigned char));
						GifConvertRGBtoRGBA( pucColorMap,  pucRGBALocal, 1 << iFramePallete);
						lpNextFrame->pucFramePalette =  pucRGBALocal ;
						lpNextFrame->iNumPalette = (1 << iFramePallete) ;

						lpNextFrame->bGlobal = E_FALSE;
					}
					else 
					{
						lpNextFrame->pucFramePalette = pstGifAttribute->pucGlobalPalette;
						lpNextFrame->iNumPalette = (1 << iNumGlobalBPP) ;

						lpNextFrame->bGlobal = E_TRUE;
					}

					
				   jdd_FSRead((JC_UINT8 *)&hFirstbyte, 1,  1, vFilePtr);

					/*Call LZW/GIF decompressor*/
					iNum = LZWDecoder(vFilePtr, (JC_INT8 *)lpNextFrame->pucFrameRaster, hFirstbyte, lpNextFrame->iFrameStride, 
						stGifId.uhWidth, stGifId.uhHeight, ((stGifId.ucPackedFields & 0x40)?1:0));

					if (!iNum)
					{
						break ;
				  	}
		            
					if(!GifAddFrame(pstGifAttribute, lpNextFrame))
					{
						break ;
					}
					
					lpNextFrame				= (ST_FRAME_ATTRIBUTE *)JC_NULL ;
					iGrapExt	= E_FALSE;
				}
				else if (ucCharGot == 0x3b) {
					bRet = E_TRUE ;
					break; 
				}

			} while (E_TRUE) ;

			if(!bRet)
			{
				jdd_MemFree(lpNextFrame);
			}

			if( pucColorMap)
			{
				jdd_MemFree( pucColorMap);
			}

			pstGifAttribute->iTransparentColor = TRANSPARENT_COLOR;
		}
		else
		{
			rCode = JC_ERR_IMG_FORMAT;
        }
   }
   else
   {
	   rCode =  JC_ERR_FILE_OPEN ;
   }
	return rCode;
}