haljpeg.~c

ct952 source code use for Digital Frame Photo

	WidthHeightRatio=WidthHeightRatio*256+3;
#endif
	}
	return WidthHeightRatio;
}
#endif
void HALJPEG_Decode(void)
{
#ifdef SUPPORT_JPEG_FULL_SCREEN
    WORD wSrcOffseH = 0;
    WORD wSrcOffseV = 0;
#endif //SUPPORT_JPEG_FULL_SCREEN

#ifdef CT950_STYLE
    _wHALJPEGBackupRealWidth = _wHALJPEGRealWidth;
    _wHALJPEGBackupRealHeight = _wHALJPEGRealHeight;
    if (_bJPEGIsEncodeMode != JPEG_PARSE_TYPE_THUMBNAIL)
    {
#ifdef SUPPORT_HAL_JPEG_AUTO_RATIO	
   		BYTE   HEIGHT_RATIO,WIDTH_RATIO;
		HEIGHT_RATIO=Get_HalJpeg_Panel_Ratio(_wHALJPEGRealWidth,_wHALJPEGRealHeight)&0x00ff;
		WIDTH_RATIO=(Get_HalJpeg_Panel_Ratio(_wHALJPEGRealWidth,_wHALJPEGRealHeight)>>8)&0x00ff;
		if (!_HALJPEG_GetRotateStatus())
        	{  
           	 	_wHALJPEGRealWidth = _wHALJPEGRealWidth*HEIGHT_RATIO*720/WIDTH_RATIO/480;
        	}
        	else
        	{
            		_wHALJPEGRealHeight = _wHALJPEGRealHeight*HEIGHT_RATIO*720/WIDTH_RATIO/480;
       	 }
#else	
#ifdef SUPPORT_JPEG_FULL_SCREEN
        _HALJPEG_CalcSrcPicOffsetAndTransPicSize(&wSrcOffseH, &wSrcOffseV);
#endif //SUPPORT_JPEG_FULL_SCREEN
        if (!_HALJPEG_GetRotateStatus())
        {  
            _wHALJPEGRealWidth = _wHALJPEGRealWidth*HALJPEG_PANEL_HEIGHT_RATIO*720/HALJPEG_PANEL_WIDTH_RATIO/480;
        }
        else
        {
            _wHALJPEGRealHeight = _wHALJPEGRealHeight*HALJPEG_PANEL_HEIGHT_RATIO*720/HALJPEG_PANEL_WIDTH_RATIO/480;
        }
#endif
    }

#endif
    //Do first scaling for 3 buffers to 1 buffer(the final original buffer).
    _HALJPEG_FirstScaling();

    _HALJPEG_CalculateScaling(VIEW_ZOOM100);

    //Set Scaling structure before calling JPEG
#ifdef SUPPORT_JPEG_FULL_SCREEN
    _wHALJPEGExtractHStart = wSrcOffseH;
    _wHALJPEGExtractVStart = wSrcOffseV;
#endif //SUPPORT_JPEG_FULL_SCREEN
    _HALJPEGScaling.wSrcExtractStartH = _wHALJPEGExtractHStart;
    _HALJPEGScaling.wSrcExtractStartV = _wHALJPEGExtractVStart;
    _HALJPEGScaling.wSrcExtractWidth = _wHALJPEGExtractWidth;
    _HALJPEGScaling.wSrcExtractHeight = _wHALJPEGExtractHeight;
    _HALJPEGScaling.wScalingWidth = _wHALJPEGScalingWidth;
    _HALJPEGScaling.wScalingHeight = _wHALJPEGScalingHeight;
    _HALJPEGScaling.pJPEGSetting = &__HALJPEGSetting;

    _HALJPEGDecode.wFirstScalingWidth = _wHALJPEGRealWidth;
    _HALJPEGDecode.wFirstScalingHeight = _wHALJPEGRealHeight;
    _HALJPEGDecode.pJPEGScaling = &_HALJPEGScaling;
    
#ifdef SUPPORT_COLOR_NORMALOZATOPN
	JPEGDEC_EnableColorTransform(TRUE);
#endif

    JPEG_Decode(&_HALJPEGDecode);

    //Calculate the random effect.
    _HALJPEG_CalculateRandomEffect();
    //Senshong2.78:  before display effect need reset block counter
    _wHALJPEGBlockCounter = 0;
}

//***************************************************************************
//  Function    :   HALJPEG_GetZoomFactor
//  Abstract    :   Call this function to get next zoom factor.
//  Arguments   :   none.
//  Return      :   return the zoom factor.
//  Side Effect :   none.
//  Notes       :   use __bZoomFactor as current zoom factor.
//***************************************************************************
BYTE HALJPEG_GetZoomFactor(void)
{
    if ((__bZoomFactor+1) > VIEW_ZOOM200)
        return VIEW_ZOOM25;
    else
        return (__bZoomFactor+1);
}

//***************************************************************************
//  Function    :   HALJPEG_Zoom
//  Abstract    :   Call this function to zoom in/zoom out or pan the JPEG.
//  Arguments   :   VIEW_NORAML==>fit to TV display.
//              :   VIEW_ZOOM25==>zoom out to 25% of the original image.
//              :   VIEW_ZOOM50==>zoom out to 50% of the original image.
//              :   VIEW_ZOOM100==>The original image size.
//              :   VIEW_ZOOM150==>zoom in to 150% of the original image.
//              :   VIEW_ZOOM200==>zoom in to 200% of the original image.
//              :   VIEW_ZOOM_LEFT==>pan left.
//              :   VIEW_ZOOM_RIGHT==>pan right.
//              :   VIEW_ZOOM_UP==>pan up.
//              :   VIEW_ZOOM_DOWN==>pan down.
//  Return      :   TRUE: The action is done.
//              :   FALSE: The action is invalid.
//  Side Effect :   none.
//  Notes       :
//***************************************************************************
BYTE HALJPEG_Zoom(BYTE bAction)
{
    if ((bAction == VIEW_ZOOM_LEFT) ||
        (bAction == VIEW_ZOOM_RIGHT) ||
        (bAction == VIEW_ZOOM_UP) ||
        (bAction == VIEW_ZOOM_DOWN))
    {
        if (__bZoomFactor <= VIEW_ZOOM100) //Doesn't need to pan
            return FALSE;

        if (!_bHALJPEGScalingAll) //Extract part of the image from the FOrg.
        {
            bAction = _HALJPEG_TransformPanAction(bAction);

            //Calculate the pan pixels
            _wHALJPEGTemp1 = (WORD)((DWORD)HALJPEG_PAN_PIXELS * (DWORD)_wHALJPEGExtractWidth / (DWORD)__HALJPEGSetting.wDisplayWidth);
            _HALJPEG_ForceTo8Multiple(&_wHALJPEGTemp1);

            switch (bAction)
            {
            case VIEW_ZOOM_LEFT:
                if (_wHALJPEGExtractHStart == 0)
                    return HAL_ZOOM_FAIL;
                else if (_wHALJPEGExtractHStart <= _wHALJPEGTemp1)
                    _wHALJPEGExtractHStart = 0;
                else
                    _wHALJPEGExtractHStart -= _wHALJPEGTemp1;
                break;
            case VIEW_ZOOM_RIGHT:
                if (_wHALJPEGExtractHStart == (_wHALJPEGRealWidth - _wHALJPEGExtractWidth))
                    return HAL_ZOOM_FAIL;
                else if ((_wHALJPEGExtractHStart + _wHALJPEGExtractWidth + _wHALJPEGTemp1) >= _wHALJPEGRealWidth)
                    _wHALJPEGExtractHStart = _wHALJPEGRealWidth - _wHALJPEGExtractWidth;
                else
                    _wHALJPEGExtractHStart += _wHALJPEGTemp1;
                break;
            case VIEW_ZOOM_UP:
                if (_wHALJPEGExtractVStart == 0)
                    return FALSE;
                else if (_wHALJPEGExtractVStart <= _wHALJPEGTemp1)
                    _wHALJPEGExtractVStart = 0;
                else
                    _wHALJPEGExtractVStart -= _wHALJPEGTemp1;
                break;
            case VIEW_ZOOM_DOWN:
                if (_wHALJPEGExtractVStart == (_wHALJPEGRealHeight - _wHALJPEGExtractHeight))
                    return HAL_ZOOM_FAIL;
                else if ((_wHALJPEGExtractVStart + _wHALJPEGExtractHeight + _wHALJPEGTemp1) >= _wHALJPEGRealHeight)
                    _wHALJPEGExtractVStart = _wHALJPEGRealHeight - _wHALJPEGExtractHeight;
                else
                    _wHALJPEGExtractVStart += _wHALJPEGTemp1;
                break;
            default:
                break;
            }

            //Re-caling the JPEG in the original buffer to display buffer and show it.
            _HALJPEG_DoZoomPanReScaling();
        }
        else //Extract all image from original buffer. (zoom mode > _fScalingRate)
        {
            if (_wHALJPEGScalingRate < 1000)
            {
                //Calculate the pan pixels
                _wHALJPEGTemp1 = (WORD)((DWORD)HALJPEG_PAN_PIXELS*(DWORD)__HALJPEGSetting.wDisplayWidth/(DWORD)HALJPEG_DISPLAY_BUF_WIDTH*100L/(DWORD)_bHALJPEGZoomRate);
                //The "pan pixel" have to be 8's multipe?

                //Don't pan the black region
                //To get the rotating status. Rotating 90 degree==>TRUE. Else==>FALSE.
                _bHALJPEGTemp = _HALJPEG_GetRotateStatus();
                switch (bAction)
                {
                case VIEW_ZOOM_LEFT:
                case VIEW_ZOOM_RIGHT:
                    if (_bHALJPEGTemp)
                    {
                        if (_wHALJPEGClipWidth >= _wHALJPEGScalingHeight)
                            return FALSE;
                    }
                    else
                    {
                        if (_wHALJPEGClipWidth >= _wHALJPEGScalingWidth)
                            return FALSE;
                    }
                case VIEW_ZOOM_UP:
                case VIEW_ZOOM_DOWN:
                    if (_bHALJPEGTemp)
                    {
                        if (_wHALJPEGClipHeight >= _wHALJPEGScalingWidth)
                            return FALSE;
                    }
                    else
                    {
                        if (_wHALJPEGClipHeight >= _wHALJPEGScalingHeight)
                            return FALSE;
                    }
                default:
                    break;
                }
            }
            else
                _wHALJPEGTemp1 = HALJPEG_PAN_PIXELS * _wHALJPEGClipWidth / HALJPEG_DISPLAY_BUF_WIDTH;

            _wHALJPEGTemp = _HALJPEG_GetPanBoundary(bAction);
            switch (bAction)
            {
            case VIEW_ZOOM_LEFT:
                if (_wHALJPEGClipHStart == _wHALJPEGTemp)
                    return FALSE;
                else if (_wHALJPEGClipHStart < (_wHALJPEGTemp1 + _wHALJPEGTemp))
                    _wHALJPEGClipHStart = _wHALJPEGTemp;
                else
                    _wHALJPEGClipHStart -= _wHALJPEGTemp1;
                break;
            case VIEW_ZOOM_RIGHT:
                if (_wHALJPEGClipHStart == _wHALJPEGTemp)
                    return FALSE;
                else if ((_wHALJPEGClipHStart + _wHALJPEGTemp1) > _wHALJPEGTemp)
                    _wHALJPEGClipHStart = _wHALJPEGTemp;
                else
                    _wHALJPEGClipHStart += _wHALJPEGTemp1;
                break;
            case VIEW_ZOOM_UP:
                if (_wHALJPEGClipVStart == _wHALJPEGTemp)
                    return FALSE;
                else if (_wHALJPEGClipVStart < (_wHALJPEGTemp1 + _wHALJPEGTemp))
                    _wHALJPEGClipVStart = _wHALJPEGTemp;
                else
                    _wHALJPEGClipVStart -= _wHALJPEGTemp1;
                break;
            case VIEW_ZOOM_DOWN:
                if (_wHALJPEGClipVStart == _wHALJPEGTemp)
                    return FALSE;
                else if ((_wHALJPEGClipVStart + _wHALJPEGTemp1) > _wHALJPEGTemp)
                    _wHALJPEGClipVStart = _wHALJPEGTemp;
                else
                    _wHALJPEGClipVStart += _wHALJPEGTemp1;
                break;
            default:
                break;
            }

            //Set clip function here.
            _HALJPEG_Clip();

            /*
            //Re-caling the JPEG in the original buffer to display buffer and show it.
            _HALJPEG_DoZoomPanReScaling();
            */
        }
    }
    else
    {
        //_HALJPEG_CalculateScaling(bAction);

        //Re-caling the JPEG in the original buffer to display buffer and show it.
        _HALJPEG_DoZoomPanReScaling();
    }

    return TRUE;
}

//***************************************************************************
//  Function    :   HAL_JPEGTransformOperation
//  Abstract    :   Call this function to transform the result of "rotate" and "flip".
//  Arguments   :   bPreviousResult:  HALJPEG_OPERATION_I,
//              :                     HALJPEG_OPERATION_FH,
//              :                     HALJPEG_OPERATION_FV,
//              :                     HALJPEG_OPERATION_FHFV,
//              :                     HALJPEG_OPERATION_RC,
//              :                     HALJPEG_OPERATION_RCC,
//              :                     HALJPEG_OPERATION_RCFH,
//              :                     HALJPEG_OPERATION_RCFV
//              :   bCurrentOperation:  HALJPEG_OPERATION_FH,
//              :                       HALJPEG_OPERATION_FV,
//              :                       HALJPEG_OPERATION_RC,
//              :                       HALJPEG_OPERATION_RCC
//  Return      :   The operation.
//  Side Effect :   none.
//  Notes       :   Call this function to get operation before calling HALJPEG_Operation().
//***************************************************************************
BYTE HALJPEG_TransformOperation(BYTE bPreviousResult, BYTE bCurrentOperation)
{
    switch (bPreviousResult)
    {
    case HALJPEG_OPERATION_I:
        _bHALJPEGTemp = bCurrentOperation;
        break;
    case HALJPEG_OPERATION_RC:
        {
            switch (bCurrentOperation)
            {
            case HALJPEG_OPERATION_RC:
                _bHALJPEGTemp = HALJPEG_OPERATION_FHFV;
                break;
            case HALJPEG_OPERATION_RCC:
                _bHALJPEGTemp = HALJPEG_OPERATION_I;
                break;
            case HALJPEG_OPERATION_FH:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCFH;
                break;
            case HALJPEG_OPERATION_FV:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCFV;
                break;
            default:
                break;
            }
        }
        break;
    case HALJPEG_OPERATION_RCC:
        {
            switch (bCurrentOperation)
            {
            case HALJPEG_OPERATION_RC:
                _bHALJPEGTemp = HALJPEG_OPERATION_I;
                break;
            case HALJPEG_OPERATION_RCC:
                _bHALJPEGTemp = HALJPEG_OPERATION_FHFV;
                break;
            case HALJPEG_OPERATION_FH:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCFV;
                break;
            case HALJPEG_OPERATION_FV:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCFH;
                break;
            default:
                break;
            }
        }