void WebGLBuffer::BufferSubData(GLenum target, size_t dstByteOffset, size_t dataLen, const void* data) const { if (!ValidateRange(dstByteOffset, dataLen)) return; if (!CheckedInt<GLintptr>(dataLen).isValid()) return mContext->ErrorOutOfMemory("Size too large."); //// const void* uploadData = data; if (mIndexCache) { const auto cachedDataBegin = (uint8_t*)mIndexCache.get() + dstByteOffset; memcpy(cachedDataBegin, data, dataLen); uploadData = cachedDataBegin; InvalidateCacheRange(dstByteOffset, dataLen); } //// const auto& gl = mContext->gl; const ScopedLazyBind lazyBind(gl, target, this); gl->fBufferSubData(target, dstByteOffset, dataLen, uploadData); ResetLastUpdateFenceId(); }
/* ** Function Name : MFC_IOControl ** ** Function Description : This function support any process of MFC instance. */ BOOL MFC_IOControl( DWORD OpenHandle, DWORD dwIoControlCode, PBYTE pInBuf, DWORD nInBufSize, PBYTE pOutBuf, DWORD nOutBufSize, PDWORD pBytesReturned ) { MFC_HANDLE *handle; MFCInstCtx *pMfcInst; MFC_ARGS *args; int ret = MFCINST_RET_OK; unsigned char *p_buf = NULL; int n_bufsize = 0; PVOID pMarshalledInBuf = NULL; static CEDEVICE_POWER_STATE mfc_pwr_state; BOOL result = TRUE; handle = (MFC_HANDLE *) OpenHandle; ///////////////////// // Parameter Check // ///////////////////// if (handle == NULL) { LOG_MSG(LOG_TRACE, "MFC_IOControl", "OpenHandle == NULL\n"); return FALSE; } if (handle != gMfcHandlePower) { if (pInBuf == NULL) { LOG_MSG(LOG_TRACE, "MFC_IOControl", "pInBuf == NULL\n"); return FALSE; } if (nInBufSize == 0) { LOG_MSG(LOG_TRACE, "MFC_IOControl", "nInBufSize == 0\n"); return FALSE; } if ((pOutBuf != NULL) || (nOutBufSize != 0) || (pBytesReturned != NULL)) { LOG_MSG(LOG_TRACE, "MFC_IOControl", "others.....\n"); return FALSE; } } pMfcInst = handle->mfc_inst; MFC_Mutex_Lock(); switch ( dwIoControlCode ) { case IOCTL_POWER_CAPABILITIES: { RETAILMSG(1, (L"[MFC IOCTL_POWER_CAPABILITIES]\n")); PPOWER_CAPABILITIES ppc; if ( !pBytesReturned || !pOutBuf || (nOutBufSize < sizeof(POWER_CAPABILITIES)) ) { SetLastError (ERROR_INVALID_PARAMETER); MFC_Mutex_Release(); return FALSE; } __try { ppc = (PPOWER_CAPABILITIES)pOutBuf; memset(ppc, 0, sizeof(POWER_CAPABILITIES)); // support D0, D4 ppc->DeviceDx = DX_MASK(D0) | DX_MASK(D4); // no wake // no inrush // Report our nominal power consumption in uAmps rather than mWatts. ppc->Flags = POWER_CAP_PREFIX_MICRO | POWER_CAP_UNIT_AMPS; *pBytesReturned = sizeof(POWER_CAPABILITIES); RETAILMSG(1, (L"[MFC IOCTL_POWER_CAPABILITIES] leaving...\n")); } __except(EXCEPTION_EXECUTE_HANDLER) { RETAILMSG(1, (L"[MFC IOCTL_POWER_CAPABILITIES] exception...\n")); MFC_Mutex_Release(); return FALSE; } break; } case IOCTL_POWER_SET: CEDEVICE_POWER_STATE NewDx; //if caller is not kernel mode, do not allow setting power state if (GetDirectCallerProcessId() != GetCurrentProcessId()) { RETAILMSG(1, (L"[MFC IOCTL_POWER_SET] User mode access denied\r\n")); MFC_Mutex_Release(); return ERROR_ACCESS_DENIED; } __try { if (pOutBuf == NULL) { return FALSE; } NewDx = *(PCEDEVICE_POWER_STATE) pOutBuf; switch ( NewDx ) { case D0: // Power Up *(PCEDEVICE_POWER_STATE)pOutBuf = process_MFC_PowerUp(OpenHandle, &mfc_pwr_state); break; case D4: // Power Down *(PCEDEVICE_POWER_STATE)pOutBuf = process_MFC_PowerDown(OpenHandle, &mfc_pwr_state); break; default: MFC_Mutex_Release(); return FALSE; } *pBytesReturned = sizeof(CEDEVICE_POWER_STATE); } __except(EXCEPTION_EXECUTE_HANDLER) { RETAILMSG(1, (L"[MFC IOCTL_POWER_SET] exception...\n")); MFC_Mutex_Release(); return FALSE; } break; case IOCTL_MFC_MPEG4_ENC_INIT: case IOCTL_MFC_H264_ENC_INIT: case IOCTL_MFC_H263_ENC_INIT: { MFC_CODECMODE codec_mode; enc_info_t enc_info; if (dwIoControlCode == IOCTL_MFC_MPEG4_ENC_INIT) codec_mode = MP4_ENC; else if (dwIoControlCode == IOCTL_MFC_H264_ENC_INIT) codec_mode = AVC_ENC; else codec_mode = H263_ENC; if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_H263_ENC_INIT.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; // Input arguments for IOCTL_MFC_xxx_ENC_INIT enc_info.width = args->enc_init.in_width; enc_info.height = args->enc_init.in_height; enc_info.frameRateRes = args->enc_init.in_frameRateRes; enc_info.frameRateDiv = args->enc_init.in_frameRateDiv; enc_info.gopNum = args->enc_init.in_gopNum; enc_info.bitrate = args->enc_init.in_bitrate; enc_info.intraqp = args->enc_init.in_intraqp; enc_info.qpmax = args->enc_init.in_qpmax; enc_info.gamma = args->enc_init.in_gamma; /////////////////////////////////// /// Initialize MFC Instance /// /////////////////////////////////// Mfc_Clk_On(); ret = MFCInst_Enc_Init(pMfcInst, codec_mode, &enc_info); Mfc_Clk_Off(); // Output arguments for IOCTL_MFC_xxx_ENC_INIT args->enc_init.ret_code = ret; if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_H263_ENC_INIT.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; } case IOCTL_MFC_MPEG4_ENC_EXE: case IOCTL_MFC_H264_ENC_EXE: case IOCTL_MFC_H263_ENC_EXE: { int nStrmLen, nHdrLen; if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_H263_ENC_EXE.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; MFCInst_GetFramBuf(pMfcInst, &p_buf, &n_bufsize); CleanInvalidateCacheRange((PBYTE )p_buf, (PBYTE )(p_buf + n_bufsize) ); // nStrmLen is size of output stream data Mfc_Clk_On(); ret = MFCInst_Encode(pMfcInst, &nStrmLen, &nHdrLen); Mfc_Clk_Off(); MFCInst_GetLineBuf(pMfcInst, &p_buf, &n_bufsize); InvalidateCacheRange((PBYTE )p_buf, (PBYTE )(p_buf + n_bufsize) ); // Output arguments for IOCTL_MFC_xxx_ENC_EXE args->enc_exe.ret_code = ret; if (ret == MFCINST_RET_OK) { args->enc_exe.out_encoded_size = nStrmLen; args->enc_exe.out_header_size = nHdrLen; } if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_H263_ENC_EXE.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; } case IOCTL_MFC_MPEG4_DEC_INIT: case IOCTL_MFC_H263_DEC_INIT: case IOCTL_MFC_H264_DEC_INIT: case IOCTL_MFC_VC1_DEC_INIT: { MFC_CODECMODE codec_mode; if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_VC1_DEC_INIT.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; if (dwIoControlCode == IOCTL_MFC_MPEG4_DEC_INIT) { codec_mode = MP4_DEC; } else if (dwIoControlCode == IOCTL_MFC_H263_DEC_INIT) { codec_mode = MP4_DEC; } else if (dwIoControlCode == IOCTL_MFC_H264_DEC_INIT) { codec_mode = AVC_DEC; } else { codec_mode = VC1_DEC; } ///////////////////////////////// // Initialize MFC Instance // ///////////////////////////////// Mfc_Clk_On(); ret = MFCInst_Dec_Init(pMfcInst, codec_mode, args->dec_init.in_strmSize); Mfc_Clk_Off(); // Output arguments for IOCTL_MFC_xxx_DEC_INIT args->dec_init.ret_code = ret; if (ret == MFCINST_RET_OK) { args->dec_init.out_width = pMfcInst->width; args->dec_init.out_height = pMfcInst->height; } if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_VC1_DEC_INIT.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; } case IOCTL_MFC_MPEG4_DEC_EXE: case IOCTL_MFC_H263_DEC_EXE: case IOCTL_MFC_H264_DEC_EXE: case IOCTL_MFC_VC1_DEC_EXE: if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_VC1_DEC_EXE.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; MFCInst_GetLineBuf(pMfcInst, &p_buf, &n_bufsize); CleanInvalidateCacheRange((PBYTE )p_buf, (PBYTE )(p_buf + n_bufsize) ); Mfc_Clk_On(); ret = MFCInst_Decode(pMfcInst, args->dec_exe.in_strmSize); Mfc_Clk_Off(); // Output arguments for IOCTL_MFC_xxx_DEC_EXE args->dec_exe.ret_code = ret; if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_VC1_DEC_EXE.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; case IOCTL_MFC_GET_LINE_BUF_ADDR: if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_GET_LINE_BUF_ADDR.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; ret = MFCInst_GetLineBuf(pMfcInst, &p_buf, &n_bufsize); if (ret != MFCINST_RET_OK) { goto GetLineBuffCleanup; } if (handle->pStrmBuf == NULL) { // Map the Line buffer for this instance to the caller's address space // handle->hUsrProc = (HANDLE) GetDirectCallerProcessId(); handle->pStrmBuf = (PBYTE) VirtualAllocEx(handle->hUsrProc, NULL, n_bufsize, MEM_RESERVE, PAGE_NOACCESS); if (handle->pStrmBuf == NULL) { RETAILMSG(1, (L"DD::MFC VirtualAllocEx(pStrmBuf) returns FALSE.\n")); ret = MFCINST_ERR_MEMORY_ALLOCATION_FAIL; goto GetLineBuffCleanup; } result = VirtualCopyEx(handle->hUsrProc, handle->pStrmBuf, (HANDLE) GetCurrentProcessId(), p_buf, n_bufsize, PAGE_READWRITE ); if (result == FALSE){ RETAILMSG(1, (L"DD::MFC VirtualCopyEx(pStrmBuf) returns FALSE.\n")); VirtualFreeEx(handle->hUsrProc, handle->pStrmBuf, 0, MEM_RELEASE); handle->pStrmBuf = NULL; ret = MFCINST_ERR_MEMORY_ALLOCATION_FAIL; goto GetLineBuffCleanup; } } // Output arguments for IOCTL_MFC_GET_FRAM_BUF_ADDR args->get_buf_addr.out_buf_size = n_bufsize; args->get_buf_addr.out_buf_addr = (int) handle->pStrmBuf; GetLineBuffCleanup: args->get_buf_addr.ret_code = ret; if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_GET_LINE_BUF_ADDR.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; case IOCTL_MFC_GET_FRAM_BUF_ADDR: if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_GET_FRAM_BUF_ADDR.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; // Decoder case ret = MFCInst_GetFramBuf(pMfcInst, &p_buf, &n_bufsize); if (ret != MFCINST_RET_OK) { goto GetFrameBuffCleanup; } // Check Paramter if (pMfcInst->run_index * n_bufsize < 0 || (pMfcInst->run_index * n_bufsize) > (int)(pMfcInst->nFramBufSize)) { RETAILMSG(1, (L"[MFC ERROR] IOCTL_MFC_GET_FRAM_BUF_ADDR: Run Index out of range.\r\n")); ret = MFCINST_ERR_ETC; goto GetFrameBuffCleanup; } if (handle->pFramBuf == NULL) { // Map the Frame buffer for this instance to the caller's address space // handle->hUsrProc = (HANDLE) GetDirectCallerProcessId(); handle->pFramBuf = (PBYTE) VirtualAllocEx(handle->hUsrProc, NULL, pMfcInst->nFramBufSize, MEM_RESERVE, PAGE_NOACCESS); if (handle->pFramBuf == NULL) { RETAILMSG(1, (L"DD::MFC VirtualAllocEx(pFramBuf) returns FALSE.\n")); ret = MFCINST_ERR_MEMORY_ALLOCATION_FAIL; goto GetFrameBuffCleanup; } result= VirtualCopyEx(handle->hUsrProc, // HANDLE hDstProc handle->pFramBuf, (HANDLE) GetCurrentProcessId(), // HANDLE hSrcProc pMfcInst->pFramBuf, pMfcInst->nFramBufSize, PAGE_READWRITE); if (result == FALSE) { RETAILMSG(1, (L"DD::MFC VirtualCopyEx(pFramBuf) returns FALSE.\n")); VirtualFreeEx(handle->hUsrProc, handle->pFramBuf, 0, MEM_RELEASE); handle->pFramBuf = NULL; ret = MFCINST_ERR_MEMORY_ALLOCATION_FAIL; goto GetFrameBuffCleanup; } } if (pMfcInst->run_index >= 0) { args->get_buf_addr.out_buf_addr = (int) (handle->pFramBuf + (pMfcInst->run_index * n_bufsize)); #if (MFC_ROTATE_ENABLE == 1) // If PostRotMode is enabled, then the output YUV buffer will be different. // In VC-1 mode, the rotated output will be the original one. if ( (pMfcInst->codec_mode != VC1_DEC) && (pMfcInst->PostRotMode & 0x0010) ) { args->get_buf_addr.out_buf_addr = (int) (handle->pFramBuf + (pMfcInst->frambufCnt * n_bufsize)); } #endif } else { args->get_buf_addr.out_buf_addr = 0; } args->get_buf_addr.out_buf_size = n_bufsize; GetFrameBuffCleanup: args->get_buf_addr.ret_code = ret; if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_GET_FRAM_BUF_ADDR.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; case IOCTL_MFC_GET_PHY_FRAM_BUF_ADDR: if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_GET_PHY_FRAM_BUF_ADDR.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; // Decoder case ret = MFCInst_GetFramBufPhysical(pMfcInst, &p_buf, &n_bufsize); // Output arguments for IOCTL_MFC_xxx_DEC_EXE args->get_buf_addr.ret_code = ret; if (ret == MFCINST_RET_OK) { // Output arguments for IOCTL_MFC_GET_FRAM_BUF_ADDR args->get_buf_addr.out_buf_addr = (int) p_buf; args->get_buf_addr.out_buf_size = n_bufsize; } if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_GET_PHY_FRAM_BUF_ADDR.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; case IOCTL_MFC_GET_MPEG4_ASP_PARAM: if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_GET_MPEG4_ASP_PARAM.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; #if (defined(DIVX_ENABLE) && (DIVX_ENABLE == 1)) ret = MFCINST_RET_OK; args->mpeg4_asp_param.ret_code = MFCINST_RET_OK; args->mpeg4_asp_param.mp4asp_vop_time_res = pMfcInst->RET_DEC_SEQ_INIT_BAK_MP4ASP_VOP_TIME_RES; args->mpeg4_asp_param.byte_consumed = pMfcInst->RET_DEC_PIC_RUN_BAK_BYTE_CONSUMED; args->mpeg4_asp_param.mp4asp_fcode = pMfcInst->RET_DEC_PIC_RUN_BAK_MP4ASP_FCODE; args->mpeg4_asp_param.mp4asp_time_base_last = pMfcInst->RET_DEC_PIC_RUN_BAK_MP4ASP_TIME_BASE_LAST; args->mpeg4_asp_param.mp4asp_nonb_time_last = pMfcInst->RET_DEC_PIC_RUN_BAK_MP4ASP_NONB_TIME_LAST; args->mpeg4_asp_param.mp4asp_trd = pMfcInst->RET_DEC_PIC_RUN_BAK_MP4ASP_MP4ASP_TRD; #if (_WIN32_WCE >= 600) if (handle->pFramBuf != NULL){ args->mpeg4_asp_param.mv_addr = ((unsigned int) handle->pFramBuf) + (pMfcInst->mv_mbyte_addr - pMfcInst->phyadrFramBuf); args->mpeg4_asp_param.mb_type_addr = args->mpeg4_asp_param.mv_addr + 25920; args->mpeg4_asp_param.mv_size = 25920; // '25920' is the maximum MV size (=45*36*16) args->mpeg4_asp_param.mb_type_size = 1620; // '1620' is the maximum MBTYE size (=45*36*1) } #else args->mpeg4_asp_param.mv_addr = ((unsigned int) pMfcInst->pFramBuf) + (pMfcInst->mv_mbyte_addr - pMfcInst->phyadrFramBuf); args->mpeg4_asp_param.mb_type_addr = args->mpeg4_asp_param.mv_addr + 25920; args->mpeg4_asp_param.mv_size = 25920; args->mpeg4_asp_param.mb_type_size = 1620; #endif InvalidateCacheRange((PBYTE )args->mpeg4_asp_param.mv_addr, (PBYTE )(args->mpeg4_asp_param.mv_addr + args->mpeg4_asp_param.mv_size) ); InvalidateCacheRange((PBYTE )args->mpeg4_asp_param.mb_type_addr , (PBYTE )(args->mpeg4_asp_param.mb_type_addr + args->mpeg4_asp_param.mb_type_size) ); #endif if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_GET_MPEG4_ASP_PARAM.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; case IOCTL_MFC_GET_CONFIG: if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_GET_CONFIG.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; ret = MFC_GetConfigParams(pMfcInst, args); if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_GET_CONFIG.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; case IOCTL_MFC_SET_CONFIG: if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR, TRUE))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_SET_CONFIG.\r\n"))); MFC_Mutex_Release(); return FALSE; } args = (MFC_ARGS *)pMarshalledInBuf; Mfc_Clk_On(); ret = MFC_SetConfigParams(pMfcInst, args); Mfc_Clk_Off(); if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pInBuf, nInBufSize, ARG_IO_PTR))) { RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_SET_CONFIG.\r\n"))); MFC_Mutex_Release(); return FALSE; } break; default: RETAILMSG(1, (L"[MFC IOControl] Requested ioctl command is not defined. (ioctl cmd=0x%X)\n", dwIoControlCode)); MFC_Mutex_Release(); return FALSE; } MFC_Mutex_Release(); switch (ret) { case MFCINST_RET_OK: return TRUE; default: return FALSE; } return FALSE; }
/*---------------------------------------------------------------------------- *Function: CMM_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 CMM_IOControl( DWORD OpenHandle, DWORD dwIoControlCode, PBYTE pInBuf, DWORD nInBufSize, PBYTE pOutBuf, DWORD nOutBufSize, PDWORD pBytesReturned ) { CODEC_MEM_CTX *CodecMem; BOOL result = TRUE; DWORD ret; UINT8 *u_addr; ALLOC_MEM_T *node; CMM_ALLOC_PRAM_T allocParam; CodecMem = (CODEC_MEM_CTX *)OpenHandle; if(!CodecMem){ RETAILMSG(1, (TEXT("[CMM_IOControl] CMM Invalid Input Handle\r\n"))); return FALSE; } if ((pInBuf == NULL) || (nInBufSize == 0)){ RETAILMSG(1, (TEXT("[CMM_IOControl] Invalid Input buffer or size\r\n"))); return FALSE; } ret = LockCMMMutex(); if(!ret){ RETAILMSG(1, (TEXT("[CMM_IOControl] CMM Mutex Lock Fail\r\n"))); return FALSE; } switch ( dwIoControlCode ) { case IOCTL_CODEC_MEM_ALLOC: printD("\n[%d][CMM_IOControl] IOCTL_CODEC_MEM_ALLOC\n", CodecMem->inst_no); if ((pInBuf == NULL) || (nInBufSize < sizeof(CMM_ALLOC_PRAM_T)) || (pOutBuf == NULL) || (nOutBufSize < sizeof(UINT))) { RETAILMSG(1, (TEXT("[CMM_IOControl] IOCTL_CODEC_MEM_ALLOC Invalid parameters\r\n"))); result = FALSE; break; } // Create a local copy of the input buffer first. if (!CeSafeCopyMemory(&allocParam, pInBuf, sizeof(CMM_ALLOC_PRAM_T)))// Copies memory inside a __try/__except block { result = FALSE; break; } if((allocParam.size) & (0xFFF)) // For 4K alignment { allocParam.size = (allocParam.size & 0xFFFFF000) + 0x1000; } printD("[IOCTL_CODEC_MEM_ALLOC] buffSize : %ld\n", allocParam.size); if((node = GetCodecVirAddr(CodecMem->inst_no, &allocParam)) == NULL){ result = FALSE; break; } CodecMem->callerProcess = (HANDLE) GetDirectCallerProcessId(); node->u_addr = (PBYTE)VirtualAllocEx(CodecMem->callerProcess, NULL, node->size, MEM_RESERVE, PAGE_NOACCESS); if (node->u_addr == NULL) { RETAILMSG(1, (_T("[CMM_IOControl]: Memory VirtualAlloc Fail. Error = %d\r\n"), GetLastError())); result = FALSE; } else { if (!VirtualCopyEx(CodecMem->callerProcess, node->u_addr, (HANDLE) GetCurrentProcessId(), node->v_addr, node->size, allocParam.cacheFlag ? PAGE_READWRITE : (PAGE_READWRITE | PAGE_NOCACHE))) { RETAILMSG(1, (_T("[CMM_IOControl]: Memory VirtualCopyEx Fail. Error = %d\r\n"), GetLastError())); result = FALSE; } } __try { if (result) { *((UINT *)pOutBuf) = (UINT) node->u_addr; } } __except ( EXCEPTION_EXECUTE_HANDLER ) { RETAILMSG( 1, ( _T("[CMM_IOControl]: exception in IOCTL_CODEC_MEM_ALLOC \r\n")) ); result = FALSE; } if (!result) { // free alloc node ReleaseAllocMem(node, CodecMem); } break; case IOCTL_CODEC_MEM_FREE: printD("\n[%d][CMM_IOControl] IOCTL_CODEC_MEM_FREE\n", CodecMem->inst_no); u_addr = (UINT8 *)pInBuf; printD("[CMM_IOControl] free adder : 0x%x \n", u_addr); for(node = AllocMemHead; node != AllocMemTail; node = node->next) { if(node->u_addr == u_addr) break; } if(node == AllocMemTail) { RETAILMSG(1, (TEXT("[CMM_IOControl] invalid virtual address(0x%x)\r\n"), u_addr)); result = FALSE; break; } // free alloc node ReleaseAllocMem(node, CodecMem); break; case IOCTL_CODEC_CACHE_INVALIDATE: printD("\n[CMM_IOControl] IOCTL_CODEC_CACHE_INVALIDATE\n"); u_addr = (UINT8 *)pInBuf; printD("[CMM_IOControl] flush adder : 0x%x \n", u_addr); for(node = AllocMemHead; node != AllocMemTail; node = node->next) { if(node->u_addr == u_addr) break; } if(node == AllocMemTail){ RETAILMSG(1, (TEXT("[%d][CMM_IOControl] invalid virtual address(0x%x)\r\n"), CodecMem->inst_no, u_addr)); result = FALSE; break; } InvalidateCacheRange((PBYTE) node->v_addr, (PBYTE) node->v_addr + node->size); break; case IOCTL_CODEC_CACHE_CLEAN: printD("\n[CMM_IOControl] IOCTL_CODEC_CACHE_CLEAN\n"); u_addr = (UINT8 *)pInBuf; printD("[CMM_IOControl] flush adder : 0x%x \n", u_addr); for(node = AllocMemHead; node != AllocMemTail; node = node->next) { if(node->u_addr == u_addr) break; } if(node == AllocMemTail){ RETAILMSG(1, (TEXT("[%d][CMM_IOControl] invalid virtual address(0x%x)\r\n"), CodecMem->inst_no, u_addr)); result = FALSE; break; } CleanCacheRange((PBYTE) node->v_addr, (PBYTE) node->v_addr + node->size); break; // IOCTL_CODEC_CACHE_FLUSH is same as IOCTL_CODEC_CACHE_CLEAN_INVALIDATE. // This is remained for backward capability case IOCTL_CODEC_CACHE_FLUSH: case IOCTL_CODEC_CACHE_CLEAN_INVALIDATE: printD("\n[CMM_IOControl] IOCTL_CODEC_CACHE_CLEAN_INVALIDATE\n"); u_addr = (UINT8 *)pInBuf; printD("[CMM_IOControl] flush adder : 0x%x \n", u_addr); for(node = AllocMemHead; node != AllocMemTail; node = node->next) { if(node->u_addr == u_addr) break; } if(node == AllocMemTail){ RETAILMSG(1, (TEXT("[%d][CMM_IOControl] invalid virtual address(0x%x)\r\n"), CodecMem->inst_no, u_addr)); result = FALSE; break; } CleanInvalidateCacheRange((PBYTE) node->v_addr, (PBYTE) node->v_addr + node->size); break; case IOCTL_CODEC_GET_PHY_ADDR: u_addr = (UINT8 *)pInBuf; for(node = AllocMemHead; node != AllocMemTail; node = node->next) { if(node->u_addr == u_addr) break; } if(node == AllocMemTail){ RETAILMSG(1, (TEXT("[CMM_IOControl] invalid virtual address(0x%x)\r\n"), u_addr)); result = FALSE; break; } if ((pOutBuf == NULL) || (nOutBufSize < sizeof(UINT8 *))) { RETAILMSG(1, (TEXT("[CMM_IOControl] IOCTL_CODEC_GET_PHY_ADDR Invalid Output buffer or size\r\n"))); result = FALSE; break; } __try { *((UINT *)pOutBuf) = (UINT) node->cached_p_addr; } __except ( EXCEPTION_EXECUTE_HANDLER ) { RETAILMSG( 1, ( _T("[CMM_IOControl]: exception in IOCTL_CODEC_GET_PHY_ADDR \r\n")) ); result = FALSE; } break; default : RETAILMSG(1, (TEXT("[CMM_IOControl] CMM Invalid IOControl\r\n"))); } UnlockCMMMutex(); return result; }
int MFC_SetConfigParams( MFCInstCtx *pMfcInst, MFC_ARGS *args // Input arguments for IOCTL_MFC_SET_CONFIG ) { int ret; unsigned int param_change_enable, param_change_val; param_change_enable = 0; switch (args->set_config.in_config_param) { case MFC_SET_CONFIG_DEC_ROTATE: #if (MFC_ROTATE_ENABLE == 1) args->set_config.out_config_value_old[0] = MFCInst_Set_PostRotate(pMfcInst, args->set_config.in_config_value[0]); #else LOG_MSG(LOG_ERROR, "MFC_SetConfigParams", "IOCTL_MFC_SET_CONFIG with MFC_SET_CONFIG_DEC_ROTATE is not supported.\r\n"); LOG_MSG(LOG_ERROR, "MFC_SetConfigParams", "Please check if MFC_ROTATE_ENABLE is defined as 1 in MfcConfig.h file.\r\n"); #endif ret = MFCINST_RET_OK; break; case MFC_SET_CONFIG_DEC_OPTION: ret = MFCINST_RET_OK; break; case MFC_SET_CONFIG_ENC_H263_PARAM: args->set_config.out_config_value_old[0] = pMfcInst->h263_annex; pMfcInst->h263_annex = args->set_config.in_config_value[0]; ret = MFCINST_RET_OK; break; case MFC_SET_CONFIG_ENC_SLICE_MODE: if (pMfcInst->enc_num_slices) { args->set_config.out_config_value_old[0] = 1; args->set_config.out_config_value_old[1] = pMfcInst->enc_num_slices; } else { args->set_config.out_config_value_old[0] = 0; args->set_config.out_config_value_old[1] = 0; } if (args->set_config.in_config_value[0]) pMfcInst->enc_num_slices = args->set_config.in_config_value[1]; else pMfcInst->enc_num_slices = 0; ret = MFCINST_RET_OK; break; case MFC_SET_CONFIG_ENC_PARAM_CHANGE: switch (args->set_config.in_config_value[0]) { case ENC_PARAM_GOP_NUM: param_change_enable = (1 << 0); break; case ENC_PARAM_INTRA_QP: param_change_enable = (1 << 1); break; case ENC_PARAM_BITRATE: param_change_enable = (1 << 2); break; case ENC_PARAM_F_RATE: param_change_enable = (1 << 3); break; case ENC_PARAM_INTRA_REF: param_change_enable = (1 << 4); break; case ENC_PARAM_SLICE_MODE: param_change_enable = (1 << 5); break; default: break; } param_change_val = args->set_config.in_config_value[1]; ret = MFCInst_EncParamChange(pMfcInst, param_change_enable, param_change_val); break; case MFC_SET_CONFIG_ENC_CUR_PIC_OPT: switch (args->set_config.in_config_value[0]) { case ENC_PIC_OPT_IDR: pMfcInst->enc_pic_option ^= (args->set_config.in_config_value[1] << 1); break; case ENC_PIC_OPT_SKIP: pMfcInst->enc_pic_option ^= (args->set_config.in_config_value[1] << 0); break; case ENC_PIC_OPT_RECOVERY: pMfcInst->enc_pic_option ^= (args->set_config.in_config_value[1] << 24); break; default: break; } ret = MFCINST_RET_OK; break; case MFC_SET_CACHE_CLEAN: //printf("MFC_SET_CACHE_CLEAN : start(0x%08x) size(0x%x)\n", args->set_config.in_config_value[0], args->set_config.in_config_value[1]); CleanCacheRange((PBYTE )args->set_config.in_config_value[0], (PBYTE )(args->set_config.in_config_value[0] + args->set_config.in_config_value[1] ) ); ret = MFCINST_RET_OK; break; case MFC_SET_CACHE_INVALIDATE: //printf("MFC_SET_CACHE_INVALIDATE : start(0x%08x) size(0x%x)\n", args->set_config.in_config_value[0], args->set_config.in_config_value[1]); InvalidateCacheRange((PBYTE )args->set_config.in_config_value[0], (PBYTE )(args->set_config.in_config_value[0] + args->set_config.in_config_value[1] ) ); ret = MFCINST_RET_OK; break; case MFC_SET_CACHE_CLEAN_INVALIDATE: //printf("MFC_SET_CACHE_CLEAN_INVALIDATE : start(0x%08x) size(0x%x)\n", args->set_config.in_config_value[0], args->set_config.in_config_value[1]); CleanInvalidateCacheRange((PBYTE )args->set_config.in_config_value[0], (PBYTE )(args->set_config.in_config_value[0] + args->set_config.in_config_value[1] ) ); ret = MFCINST_RET_OK; break; #if (defined(DIVX_ENABLE) && (DIVX_ENABLE == 1)) case MFC_SET_PADDING_SIZE: // printf("MFC_SET_PADDING_SIZE : paddingsize(%d)\n", args->set_config.in_config_value[0]); pMfcInst->paddingSize = args->set_config.in_config_value[0]; ret = MFCINST_RET_OK; break; #endif default: ret = -1; } // Output arguments for IOCTL_MFC_SET_CONFIG args->set_config.ret_code = ret; return MFCINST_RET_OK; }