jpgdriver.c

6410BSP3

        if (result== FALSE)
            RETAILMSG(1, (L"DD::JPG  VirtualFreeEx(rgbBuf) returns FALSE.\n"));
        JPGRegCtx->rgbBuf = NULL;
    }
}
#else
{
    printD("JPGRegCtx->callerProcess : 0x%x\n", JPGRegCtx->callerProcess);

    if(JPGRegCtx->strUserBuf != NULL)
    {
        printD("decommit strUsrBuf\n");
        result = VirtualFreeEx( JPGRegCtx->callerProcess,    // HANDLE hProcess
                                JPGRegCtx->strUserBuf,
                                JPG_STREAM_BUF_SIZE,
                                MEM_DECOMMIT);
        if (result == FALSE)
            RETAILMSG(1, (L"DD::JPG VirtualFreeEx(strUserBuf) returns FALSE.\n"));
    }

    if(JPGRegCtx->strUserThumbBuf != NULL)
    {
        printD("decommit strUserThumbBuf\n");
        result = VirtualFreeEx( JPGRegCtx->callerProcess,    // HANDLE hProcess
                                JPGRegCtx->strUserThumbBuf,
                                JPG_STREAM_THUMB_BUF_SIZE,
                                MEM_DECOMMIT);
        if (result == FALSE)
            RETAILMSG(1, (L"DD::JPG  VirtualFreeEx(strUserThumbBuf) returns FALSE.\n"));
    }

    if(JPGRegCtx->frmUserBuf != NULL)
    {
        printD("decommit frmUserBuf\n");
        result = VirtualFreeEx( JPGRegCtx->callerProcess,    // HANDLE hProcess
                                JPGRegCtx->strUserBuf,
                                JPG_STREAM_BUF_SIZE,
                                MEM_DECOMMIT);
        if (result == FALSE)
            RETAILMSG(1, (L"DD::JPG  VirtualFreeEx(STRM_BUF) returns FALSE.\n"));
    }

    if(JPGRegCtx->frmUserThumbBuf != NULL)
    {
        printD("decommit frmUserThumbBuf\n");
        result = VirtualFreeEx( JPGRegCtx->callerProcess,    // HANDLE hProcess
                                JPGRegCtx->frmUserThumbBuf,
                                JPG_FRAME_THUMB_BUF_SIZE,
                                MEM_DECOMMIT);
        if (result == FALSE)
            RETAILMSG(1, (L"DD::JPG  VirtualFreeEx(frmUserThumbBuf) returns FALSE.\n"));
    }

    if(JPGRegCtx->rgbBuf != NULL)
    {
        printD("decommit rgbBuf\n");
        result = VirtualFreeEx( JPGRegCtx->callerProcess,    // HANDLE hProcess
                                JPGRegCtx->rgbBuf,
                                JPG_RGB_BUF_SIZE,
                                MEM_DECOMMIT);
        if (result == FALSE)
            RETAILMSG(1, (L"DD::JPG  VirtualFreeEx(rgbBuf) returns FALSE.\n"));
    }
}
#endif

#endif

    UnlockJPGMutex();

    JPGPowerControl(FALSE);
    return TRUE;
}


/*----------------------------------------------------------------------------
*Function: JPG_IOControl

*Parameters:         OpenHandle        :
                    dwIoControlCode    :
*Return Value:        True/False
*Implementation Notes: JPEG_IOControl sends commands to initiate different
*                       operations like Init,Decode and Deinit.The test
*                       application uses the DeviceIOControl function to
*                       specify an operation to perform
-----------------------------------------------------------------------------*/
BOOL
JPG_IOControl(
    DWORD OpenHandle,
    DWORD dwIoControlCode,
    PBYTE pInBuf,
    DWORD nInBufSize,
    PBYTE pOutBuf,
    DWORD nOutBufSize,
    PDWORD pBytesReturned
    )
{
    S3C6410_JPG_CTX *JPGRegCtx;
    JPG_DEC_PROC_PARAM *DecReturn;
    JPG_ENC_PROC_PARAM *EncParam;
    
    BOOL    result = TRUE;
    DWORD    ret;
    ULONGLONG    phyAddr;

    PVOID pMarshalledInBuf     = NULL;
    PVOID pMarshalledOutBuf = NULL;

    printD("DD::IOCTL\n");
    
    if(PowerChange == TRUE)
    {
        RETAILMSG(1, (TEXT("DD::Power state is changed after open\r\n")));
        return FALSE;
    }

    JPGRegCtx = (S3C6410_JPG_CTX *)OpenHandle;
    if(!JPGRegCtx)
    {
        RETAILMSG(1, (TEXT("DD::JPG Invalid Input Handle\r\n")));
        return FALSE;
    }

    ret = LockJPGMutex();
    if(!ret)
    {
        RETAILMSG(1, (TEXT("DD::JPG Mutex Lock Fail\r\n")));
        return FALSE;
    }

    switch ( dwIoControlCode )
    {
    case IOCTL_JPG_DECODE:
        printD("DD::IOCTL_JPEG_DECODE\n");
        DecReturn = (JPG_DEC_PROC_PARAM *)pBytesReturned;

        result = decodeJPG(JPGRegCtx, DecReturn);
        printD("DD::width : %d hegiht : %d size : %d\n",
            DecReturn->width, DecReturn->height, DecReturn->dataSize);
        break;

    case IOCTL_JPG_ENCODE:
        printD("DD::IOCTL_JPEG_ENCODE\n");
        EncParam = (JPG_ENC_PROC_PARAM *)pBytesReturned;
        printD("DD::width : %d hegiht : %d enctype : %d quality : %d\n",
            EncParam->width, EncParam->height, EncParam->encType, EncParam->quality);

        result = encodeJPG(JPGRegCtx, EncParam);
        printD("DD::encoded file size : %d\n", EncParam->fileSize);
        break;

    case IOCTL_JPG_GET_STRBUF:
        printD("DD::IOCTL_JPG_GET_STRBUF\n");

        if(FAILED(CeOpenCallerBuffer(&pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR, FALSE)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeOpenCallerBuffer failed in IOCTL_JPG_GET_STRBUF.\r\n")));
            return FALSE;
        }

#if    (_WIN32_WCE >= 600)
#ifdef E2E
{
        if(JPGRegCtx->strUserBuf == NULL)
        {
            JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
            JPGRegCtx->strUserBuf = VirtualAllocEx(JPGRegCtx->callerProcess, NULL, JPG_STREAM_BUF_SIZE, MEM_RESERVE, PAGE_NOACCESS);
            phyAddr = JPG_DATA_BASE_ADDR;
            result= VirtualCopyEx(JPGRegCtx->callerProcess,           // HANDLE hDstProc
                                 JPGRegCtx->strUserBuf,
                                 (HANDLE) GetCurrentProcessId(),     // HANDLE hSrcProc
                                          (PVOID)(phyAddr >> 8),    
                                           JPG_STREAM_BUF_SIZE,
                                           PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE);
            if (result== FALSE)
            {
                    RETAILMSG(1, (L"DD::JPG VirtualCopyEx(strUserBuf) returns FALSE.\n"));
            *((UINT *)pMarshalledOutBuf) = NULL;
                    break;
            }
        }
        printD("DD::strUserBuf : 0x%08x CallerProcessID : 0x%x\n", JPGRegCtx->strUserBuf, JPGRegCtx->callerProcess);
    *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->strUserBuf;
}        
#else
{
        JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
        JPGRegCtx->strUserBuf = (PBYTE) VirtualAllocCopyEx( (HANDLE) GetCurrentProcessId(),        // HANDLE hSrcProc
            JPGRegCtx->callerProcess,    // HANDLE hDstProc
            (LPVOID)JPGRegCtx->v_pJPGData_Buff,
            JPG_STREAM_BUF_SIZE,
            PAGE_READWRITE);
        if (JPGRegCtx->strUserBuf == NULL)
        {
            RETAILMSG(1, (TEXT("DD::JPG Memory Allocation Fail\r\n")));
            UnlockJPGMutex();
            return FALSE;
        }
        else
        {
            printD("DD::strUserBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->strUserBuf, JPGRegCtx->callerProcess);
            *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->strUserBuf;
        }
}
#endif

#else
        *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff;
#endif

        if(FAILED(CeCloseCallerBuffer(pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeCloseCallerBuffer failed in IOCTL_JPG_GET_STRBUF.\r\n")));
            return FALSE;
        }

        break;

    case IOCTL_JPG_GET_THUMB_STRBUF:
        printD("DD::IOCTL_JPG_GET_THUMB_STRBUF\n");

        if(FAILED(CeOpenCallerBuffer(&pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR, FALSE)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeOpenCallerBuffer failed in IOCTL_JPG_GET_THUMB_STRBUF.\r\n")));
            return FALSE;
        }

#if    (_WIN32_WCE >= 600)
#ifdef E2E
{
            if(JPGRegCtx->strUserThumbBuf == NULL)
            {
                JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
                JPGRegCtx->strUserThumbBuf = VirtualAllocEx(JPGRegCtx->callerProcess, NULL, JPG_STREAM_THUMB_BUF_SIZE, MEM_RESERVE, PAGE_NOACCESS);
                phyAddr = JPG_DATA_BASE_ADDR+ JPG_STREAM_BUF_SIZE;
                result= VirtualCopyEx(JPGRegCtx->callerProcess,           // HANDLE hDstProc
                                     JPGRegCtx->strUserThumbBuf,
                                     (HANDLE) GetCurrentProcessId(),     // HANDLE hSrcProc
                                                 (PVOID)(phyAddr >> 8),    
                                                  JPG_STREAM_THUMB_BUF_SIZE,
                                                  PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE);
                if (result== FALSE)
                {
                    RETAILMSG(1, (L"DD::JPG VirtualCopyEx(strUserThumbBuf) returns FALSE.\n"));
            *((UINT *)pMarshalledOutBuf) = NULL;
                    break;
                }
            }
            printD("DD::strUserThumbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->strUserThumbBuf, JPGRegCtx->callerProcess);
        *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->strUserThumbBuf;
 }
#else
{
        JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
        JPGRegCtx->strUserThumbBuf = (PBYTE) VirtualAllocCopyEx((HANDLE) GetCurrentProcessId(),        // HANDLE hSrcProc
            JPGRegCtx->callerProcess,    // HANDLE hDstProc
            (LPVOID)(JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE),
            JPG_STREAM_THUMB_BUF_SIZE,
            PAGE_READWRITE);
        if (JPGRegCtx->strUserThumbBuf == NULL)
        {
            RETAILMSG(1, (TEXT("DD::JPG Memory Allocation Fail\r\n")));
            UnlockJPGMutex();
            return FALSE;
        }
        else
        {
            printD("DD::strUserThumbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->strUserThumbBuf, JPGRegCtx->callerProcess);
            *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->strUserThumbBuf;
        }
}
#endif

#else
        *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE;
#endif

        if(FAILED(CeCloseCallerBuffer(pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeCloseCallerBuffer failed in IOCTL_JPG_GET_THUMB_STRBUF.\r\n")));
            return FALSE;
        }

        break;

    case IOCTL_JPG_GET_FRMBUF:
        printD("DD::IOCTL_JPG_GET_FRMBUF\n");

        if(FAILED(CeOpenCallerBuffer(&pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR, FALSE)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeOpenCallerBuffer failed in IOCTL_JPG_GET_FRMBUF.\r\n")));
            return FALSE;
        }

#if    (_WIN32_WCE >= 600)
#ifdef E2E
{
                if(JPGRegCtx->frmUserBuf == NULL){
                JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
                JPGRegCtx->frmUserBuf = VirtualAllocEx(JPGRegCtx->callerProcess, NULL, JPG_FRAME_BUF_SIZE, MEM_RESERVE, PAGE_NOACCESS);
                phyAddr =JPG_DATA_BASE_ADDR+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE;
                result = VirtualCopyEx(JPGRegCtx->callerProcess,           // HANDLE hDstProc
                                     JPGRegCtx->frmUserBuf,
                                     (HANDLE) GetCurrentProcessId(),     // HANDLE hSrcProc
                                                 (PVOID)(phyAddr>>8),    
                                                  JPG_FRAME_BUF_SIZE,
                                                  PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE);
                if (result == FALSE){
                    RETAILMSG(1, (L"DD::JPG VirtualCopyEx(frmUserBuf) returns FALSE.\n"));
            *((UINT *)pMarshalledOutBuf) = NULL;
                    break;
                }
                JPGRegCtx->frmUserBuf += phyAddr & (UserKInfo[KINX_PAGESIZE] - 1);
              }
            printD("DD::frmUserBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->frmUserBuf, JPGRegCtx->callerProcess);
    *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->frmUserBuf;
}
#else
{
        JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
        JPGRegCtx->frmUserBuf = (PBYTE) VirtualAllocCopyEx( (HANDLE) GetCurrentProcessId(),        // HANDLE hSrcProc
            JPGRegCtx->callerProcess,    // HANDLE hDstProc
            (LPVOID)(JPGRegCtx->v_pJPGData_Buff + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE),
            JPG_FRAME_BUF_SIZE,
            PAGE_READWRITE);
        if (JPGRegCtx->frmUserBuf == NULL)
        {
            RETAILMSG(1, (TEXT("DD::JPG Memory Allocation Fail\r\n")));
            UnlockJPGMutex();
            return FALSE;
        }
        else
        {
            printD("DD::frmUserBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->frmUserBuf, JPGRegCtx->callerProcess);
            *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->frmUserBuf;
        }
}
#endif

#else
        *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE;
#endif

        if(FAILED(CeCloseCallerBuffer(pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeCloseCallerBuffer failed in IOCTL_JPG_GET_FRMBUF.\r\n")));
            return FALSE;
        }

        break;

    case IOCTL_JPG_GET_PHY_FRMBUF:
        if(FAILED(CeOpenCallerBuffer(&pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR, FALSE)))