haljpeg.~c

ct952 source code use for Digital Frame Photo

        break;
    case HALJPEG_OPERATION_FH:
        {
            switch (bCurrentOperation)
            {
            case HALJPEG_OPERATION_RC:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCFV;
                break;
            case HALJPEG_OPERATION_RCC:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCFH;
                break;
            case HALJPEG_OPERATION_FH:
                _bHALJPEGTemp = HALJPEG_OPERATION_I;
                break;
            case HALJPEG_OPERATION_FV:
                _bHALJPEGTemp = HALJPEG_OPERATION_FHFV;
                break;
            default:
                break;
            }
        }
        break;
    case HALJPEG_OPERATION_FV:
        {
            switch (bCurrentOperation)
            {
            case HALJPEG_OPERATION_RC:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCFH;
                break;
            case HALJPEG_OPERATION_RCC:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCFV;
                break;
            case HALJPEG_OPERATION_FH:
                _bHALJPEGTemp = HALJPEG_OPERATION_FHFV;
                break;
            case HALJPEG_OPERATION_FV:
                _bHALJPEGTemp = HALJPEG_OPERATION_I;
                break;
            default:
                break;
            }
        }
        break;
    case HALJPEG_OPERATION_FHFV:
        {
            switch (bCurrentOperation)
            {
            case HALJPEG_OPERATION_RC:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCC;
                break;
            case HALJPEG_OPERATION_RCC:
                _bHALJPEGTemp = HALJPEG_OPERATION_RC;
                break;
            case HALJPEG_OPERATION_FH:
                _bHALJPEGTemp = HALJPEG_OPERATION_FV;
                break;
            case HALJPEG_OPERATION_FV:
                _bHALJPEGTemp = HALJPEG_OPERATION_FH;
                break;
            default:
                break;
            }
        }
        break;
    case HALJPEG_OPERATION_RCFH:
        {
            switch (bCurrentOperation)
            {
            case HALJPEG_OPERATION_RC:
                _bHALJPEGTemp = HALJPEG_OPERATION_FH;
                break;
            case HALJPEG_OPERATION_RCC:
                _bHALJPEGTemp = HALJPEG_OPERATION_FV;
                break;
            case HALJPEG_OPERATION_FH:
                _bHALJPEGTemp = HALJPEG_OPERATION_RC;
                break;
            case HALJPEG_OPERATION_FV:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCC;
                break;
            default:
                break;
            }
        }
        break;
    case HALJPEG_OPERATION_RCFV:
        {
            switch (bCurrentOperation)
            {
            case HALJPEG_OPERATION_RC:
                _bHALJPEGTemp = HALJPEG_OPERATION_FV;
                break;
            case HALJPEG_OPERATION_RCC:
                _bHALJPEGTemp = HALJPEG_OPERATION_FH;
                break;
            case HALJPEG_OPERATION_FH:
                _bHALJPEGTemp = HALJPEG_OPERATION_RCC;
                break;
            case HALJPEG_OPERATION_FV:
                _bHALJPEGTemp = HALJPEG_OPERATION_RC;
                break;
            default:
                break;
            }
        }
        break;
    default:
        break;
    }

    return _bHALJPEGTemp;
}


//***************************************************************************
//  Function    :   HALJPEG_Operation
//  Abstract    :   Call this function for rotate and flip. This function can be
//              :   called only when JPEG has been decoded OK and just do the "rotate"
//              :   or "flip" operation. Note: should call HALJPEG_TransformOperation()
//              :   before calling this function.
//  Arguments   :   none.
//  Return      :   none.
//  Side Effect :   none.
//  Notes       :
//***************************************************************************
void HALJPEG_Operation(void)
{
    _HALJPEG_ReScaling();

    DISP_Display(__HALJPEGSetting.bFrameBuffer, DISP_MAINVIDEO);
}

//***************************************************************************
//  Function    :   HALJPEG_Status
//  Abstract    :   Call this function to get the status of JPEG Decoder.
//  Arguments   :   bStatusType: HALJPEG_PARSE_HEADER/HALJPEG_DECODE/HALJPEG_PSFB
//  Return      :   HALJPEG_STATUS_UNFINISH/HALJPEG_STATUS_UNSUPPORT/
//              :   HALJPEG_STATUS_OK/HALJPEG_STATUS_FAIL
//  Side Effect :   none.
//  Notes       :
//***************************************************************************
BYTE HALJPEG_Status(BYTE bStatusType)
{
    switch (bStatusType)
    {
    case HALJPEG_PARSE_HEADER:
        return JPEG_Status(JPEG_PARSE_HEADER);
    case HALJPEG_DECODE:
        return JPEG_Status(JPEG_DECODE);
    case HALJPEG_PSFB:                          //tommy0.67
        return JPEG_Status(JPEG_PSFB);
    case HALJPEG_RESET:
        return JPEG_Status(JPEG_RESET);
    case HALJPEG_OPERATION:
        return JPEG_Status(JPEG_OPERATION);
    default:
        break;
    }

    return HALJPEG_STATUS_FAIL;
}

//***************************************************************************
//  Function    :   HALJPEG_Abort
//  Abstract    :   Call this function to abort JPEG decoding.
//  Arguments   :   none.
//  Return      :   none.
//  Side Effect :   none.
//  Notes       :
//***************************************************************************
void HALJPEG_Abort(void)
{
    JPEG_Abort();
}

//***************************************************************************
//  Function    :   HALJPEG_Display
//  Abstract    :   Call this function to display JPEG.
//  Arguments   :   bFrameBuf: Frame buffer 0 or 1.
//  Return      :   none.
//  Side Effect :   none.
//  Notes       :
//***************************************************************************
BYTE HALJPEG_Display(BYTE bFrameBuf)
{
    BYTE bJPEGEffect;

    //Call "slide show", "blending", "PIP" functions for effect.
    if (__bHALJPEGEffect != HALJPEG_EFFECT_NONE)
    {
        bJPEGEffect = __bHALJPEGEffect;
        if (bJPEGEffect == HALJPEG_EFFECT_RANDOM)
        {
            bJPEGEffect = _bHALJPEGRandomEffectType;
        }

        switch (bJPEGEffect)
        {
        case HALJPEG_EFFECT_COVER_UP:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_COVERUP, HALJPEG_EFFECT_LINE_V, bFrameBuf);
            break;
        case HALJPEG_EFFECT_COVER_DOWN:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_COVERDOWN, HALJPEG_EFFECT_LINE_V, bFrameBuf);
            break;
        case HALJPEG_EFFECT_COVER_LEFT:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_COVERLEFT, HALJPEG_EFFECT_LINE_H, bFrameBuf);
            break;
        case HALJPEG_EFFECT_COVER_RIGHT:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_COVERRIGHT, HALJPEG_EFFECT_LINE_H, bFrameBuf);
            break;
        case HALJPEG_EFFECT_UNCOVER_UP:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_UNCOVERUP, HALJPEG_EFFECT_LINE_V, bFrameBuf);
            break;
        case HALJPEG_EFFECT_UNCOVER_DOWN:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_UNCOVERDOWN, HALJPEG_EFFECT_LINE_V, bFrameBuf);
            break;
        case HALJPEG_EFFECT_UNCOVER_LEFT:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_UNCOVERLEFT, HALJPEG_EFFECT_LINE_H, bFrameBuf);
            break;
        case HALJPEG_EFFECT_UNCOVER_RIGHT:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_UNCOVERRIGHT, HALJPEG_EFFECT_LINE_H, bFrameBuf);
            break;
        case HALJPEG_EFFECT_WIPE_UP:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_WIPEUP, HALJPEG_EFFECT_LINE_V, bFrameBuf);
            break;
        case HALJPEG_EFFECT_WIPE_DOWN:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_WIPEDOWN, HALJPEG_EFFECT_LINE_V, bFrameBuf);
            break;
        case HALJPEG_EFFECT_WIPE_LEFT:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_WIPELEFT, HALJPEG_EFFECT_LINE_H, bFrameBuf);
            break;
        case HALJPEG_EFFECT_WIPE_RIGHT:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_WIPERIGHT, HALJPEG_EFFECT_LINE_H, bFrameBuf);
            break;
        case HALJPEG_EFFECT_PUSH_UP:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_PUSHUP, HALJPEG_EFFECT_LINE_V, bFrameBuf);
            break;
        case HALJPEG_EFFECT_PUSH_DOWN:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_PUSHDOWN, HALJPEG_EFFECT_LINE_V, bFrameBuf);
            break;
        case HALJPEG_EFFECT_PUSH_LEFT:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_PUSHLEFT, HALJPEG_EFFECT_LINE_H, bFrameBuf);
            break;
        case HALJPEG_EFFECT_PUSH_RIGHT:
            _bHALJPEGTemp = DISP_ShowEffect(SLIDESHOW_PUSHRIGHT, HALJPEG_EFFECT_LINE_H, bFrameBuf);
            break;
        case HALJPEG_EFFECT_BLIND_HOR:
        case HALJPEG_EFFECT_BLIND_VER:
        case HALJPEG_EFFECT_COLORATION_HOR:
        case HALJPEG_EFFECT_COLORATION_VER:
        case HALJPEG_EFFECT_BLOCK_1:
        case HALJPEG_EFFECT_BLOCK_2:
        case HALJPEG_EFFECT_BLOCK_3:
        case HALJPEG_EFFECT_BLOCK_4:
        case HALJPEG_EFFECT_BLOCK_5:
        case HALJPEG_EFFECT_BLOCK_6:
        case HALJPEG_EFFECT_BLOCK_7:
        case HALJPEG_EFFECT_BLOCK_8:
        case HALJPEG_EFFECT_BLOCK_9:
            _bHALJPEGTemp = HALJPEG_ShowEffect(bJPEGEffect,0,bFrameBuf);
            break;
        default:
            break;
        }
    }
    else
    {
        DISP_Display(bFrameBuf, DISP_MAINVIDEO);

        //CoCo0.95, Fix the bug about JPEG PIP is wrong.
        DISP_Display(bFrameBuf, DISP_PIP);

        DISP_DisplayCtrl(DISP_MAINVIDEO, TRUE);

        _bHALJPEGTemp = SLIDESHOW_RET_OK;
        _HALJPEG_Clip();
    }

	__wHALJPEGCurrentDisplayBuf = bFrameBuf; //CoCo2.77

    return _bHALJPEGTemp;
}

//***************************************************************************
//  Function    :   _HALJPEG_GetRotateStatus
//  Abstract    :   Get the rotating status of JPEG.
//  Arguments   :   bOperation: the operation.
//  Return          TRUE ==> The image is rotated 90 degree. (Rc or Rcc)
//              :   FALSE ==> The image is not rotated 90 degree.
//  Side Effect :   none.
//  Notes       :   none.
//***************************************************************************
BYTE _HALJPEG_GetRotateStatus(void)
{
    switch (__HALJPEGSetting.bOperation)
    {
    case HALJPEG_OPERATION_RC:
    case HALJPEG_OPERATION_RCC:
    case HALJPEG_OPERATION_RCFH:
    case HALJPEG_OPERATION_RCFV:
        return TRUE;
    default:
        break;
    }

    return FALSE;
}


//***************************************************************************
//  Function    :   _HALJPEG_GetFitWidthOrHeight
//  Abstract    :   Calculate the picture should fit width or height.
//  Arguments   :   none.
//  Return      :   none.
//  Side Effect :   none.
//  Notes       :   none.
//***************************************************************************
void _HALJPEG_GetFitWidthOrHeight(void)
{
    _bHALJPEGTemp = _HALJPEG_GetRotateStatus();
    if (_bHALJPEGTemp) //rotate 90 degree
    {
        // if (_wHALJPEGRealWidth/_wHALJPEGRealHeight > __HALJPEGSetting.wDisplayHeight/__HALJPEGSetting.wDisplayWidth)==>fit height
        //fit width
        if ((DWORD)((DWORD)_wHALJPEGRealWidth * (DWORD)__HALJPEGSetting.wDisplayWidth) >
            (DWORD)((DWORD)_wHALJPEGRealHeight * (DWORD)__HALJPEGSetting.wDisplayHeight))
        {
            _bHALJPEGFit =  HALJPEG_DISPLAY_FIT_HEIGHT;
        }
        else //fit width
        {
            _bHALJPEGFit =  HALJPEG_DISPLAY_FIT_WIDTH;
        }
    }
    else
    {
        // if (_wHALJPEGRealWidth/_wHALJPEGRealHeight < __HALJPEGSetting.wDisplayWidth/__HALJPEGSetting.wDisplayHeight)==>fit height
        //fit height
        if ((DWORD)((DWORD)_wHALJPEGRealWidth * (DWORD)__HALJPEGSetting.wDisplayHeight) <
            (DWORD)((DWORD)_wHALJPEGRealHeight * (DWORD)__HALJPEGSetting.wDisplayWidth))
        {
            _bHALJPEGFit = HALJPEG_DISPLAY_FIT_HEIGHT;