BOOL RequestPMDeviceNotifications(DWORD cNotifications, HANDLE *phNotifications) { BOOL fOk = TRUE; DWORD dwStatus; HKEY hk; TCHAR szBuf[MAX_PATH]; LPTSTR pszFname = _T("PMMON!RequestPMDeviceNotifications"); // enumerate all the device classes wsprintf(szBuf, _T("%s\\Interfaces"), PWRMGR_REG_KEY); dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szBuf, 0, 0, &hk); if(dwStatus == ERROR_SUCCESS) { DWORD dwIndex = 0; DWORD dwNotificationIndex = 0; do { DWORD cbValueName = MAX_PATH, dwType; GUID idInterface; dwStatus = RegEnumValue(hk, dwIndex, szBuf, &cbValueName, NULL, &dwType, NULL, NULL); if(dwStatus == ERROR_SUCCESS) { if(dwType != REG_SZ) { RetailPrint (_T("%s: invalid type for value '%s'\r\n"), pszFname, szBuf); } else if(!ConvertStringToGuid(szBuf, &idInterface)) { RetailPrint (_T("%s: can't convert '%s' to GUID\r\n"), pszFname, szBuf); } else if((phNotifications[dwNotificationIndex] = RequestDeviceNotifications(&idInterface, ghDeviceNotifications, TRUE)) == NULL) { RetailPrint (_T("%s: RequestDeviceNotifications('%s') failed\r\n"), pszFname, szBuf); } else { dwNotificationIndex++; } // update the index dwIndex++; } } while(dwStatus == ERROR_SUCCESS && dwNotificationIndex < cNotifications); // check for abnormal termination of the loop if(dwStatus != ERROR_NO_MORE_ITEMS) { fOk = FALSE; } // close the registry handle RegCloseKey(hk); } return fOk; }
mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* pParams) { if (1 == nArgNum) { PrintHelp(strInput[0], NULL); return MFX_ERR_UNSUPPORTED; } MSDK_CHECK_POINTER(pParams, MFX_ERR_NULL_PTR); // set default implementation pParams->bUseHWLib = true; #if defined(LIBVA_SUPPORT) pParams->libvaBackend = MFX_LIBVA_DRM; #endif for (mfxU8 i = 1; i < nArgNum; i++) { if (MSDK_CHAR('-') != strInput[i][0]) { mfxStatus sts = StrFormatToCodecFormatFourCC(strInput[i], pParams->videoType); if (sts != MFX_ERR_NONE) { PrintHelp(strInput[0], MSDK_STRING("Unknown codec")); return MFX_ERR_UNSUPPORTED; } if (!IsDecodeCodecSupported(pParams->videoType)) { PrintHelp(strInput[0], MSDK_STRING("Unsupported codec")); return MFX_ERR_UNSUPPORTED; } if (pParams->videoType == CODEC_MVC) { pParams->videoType = MFX_CODEC_AVC; pParams->bIsMVC = true; } continue; } if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sw"))) { pParams->bUseHWLib = false; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-hw"))) { pParams->bUseHWLib = true; } #if D3D_SURFACES_SUPPORT else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d"))) { pParams->memType = D3D9_MEMORY; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d11"))) { pParams->memType = D3D11_MEMORY; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-r"))) { pParams->mode = MODE_RENDERING; // use d3d9 rendering by default if (SYSTEM_MEMORY == pParams->memType) pParams->memType = D3D9_MEMORY; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-wall"))) { if(i + 6 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -wall key")); return MFX_ERR_UNSUPPORTED; } // use d3d9 rendering by default if (SYSTEM_MEMORY == pParams->memType) pParams->memType = D3D9_MEMORY; pParams->mode = MODE_RENDERING; msdk_opt_read(strInput[++i], pParams->nWallW); msdk_opt_read(strInput[++i], pParams->nWallH); msdk_opt_read(strInput[++i], pParams->nWallCell); msdk_opt_read(strInput[++i], pParams->nWallMonitor); mfxU32 nTitle; msdk_opt_read(strInput[++i], nTitle); pParams->bWallNoTitle = 0 == nTitle; msdk_opt_read(strInput[++i], pParams->nWallTimeout); } #endif #if defined(LIBVA_SUPPORT) else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vaapi"))) { pParams->memType = D3D9_MEMORY; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-r"))) { pParams->memType = D3D9_MEMORY; pParams->mode = MODE_RENDERING; pParams->libvaBackend = MFX_LIBVA_X11; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rwld"))) { pParams->memType = D3D9_MEMORY; pParams->mode = MODE_RENDERING; pParams->libvaBackend = MFX_LIBVA_WAYLAND; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-perf"))) { pParams->bPerfMode = true; } else if (0 == msdk_strncmp(strInput[i], MSDK_STRING("-rdrm"), 5)) { pParams->memType = D3D9_MEMORY; pParams->mode = MODE_RENDERING; pParams->libvaBackend = MFX_LIBVA_DRM_MODESET; if (strInput[i][5]) { if (strInput[i][5] != '-') { PrintHelp(strInput[0], MSDK_STRING("unsupported monitor type")); return MFX_ERR_UNSUPPORTED; } pParams->monitorType = getMonitorType(&strInput[i][6]); if (pParams->monitorType >= MFX_MONITOR_MAXNUMBER) { PrintHelp(strInput[0], MSDK_STRING("unsupported monitor type")); return MFX_ERR_UNSUPPORTED; } } else { pParams->monitorType = MFX_MONITOR_AUTO; // that's case of "-rdrm" pure option } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-window"))) { if(i +4 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -window key")); return MFX_ERR_UNSUPPORTED; } msdk_opt_read(strInput[++i], pParams->nRenderWinX); msdk_opt_read(strInput[++i], pParams->nRenderWinY); msdk_opt_read(strInput[++i], pParams->Width); msdk_opt_read(strInput[++i], pParams->Height); if (0 == pParams->Width) pParams->Width = 320; if (0 == pParams->Height) pParams->Height = 240; pParams->bRenderWin = true; } #endif else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-low_latency"))) { switch (pParams->videoType) { case MFX_CODEC_HEVC: case MFX_CODEC_AVC: case MFX_CODEC_JPEG: { pParams->bLowLat = true; if (!pParams->bIsMVC) break; } default: { PrintHelp(strInput[0], MSDK_STRING("-low_latency mode is suppoted only for H.264 and JPEG codecs")); return MFX_ERR_UNSUPPORTED; } } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-jpeg_rotate"))) { if(MFX_CODEC_JPEG != pParams->videoType) return MFX_ERR_UNSUPPORTED; if(i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -jpeg_rotate key")); return MFX_ERR_UNSUPPORTED; } msdk_opt_read(strInput[++i], pParams->nRotation); if((pParams->nRotation != 90)&&(pParams->nRotation != 180)&&(pParams->nRotation != 270)) { PrintHelp(strInput[0], MSDK_STRING("-jpeg_rotate is supported only for 90, 180 and 270 angles")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-calc_latency"))) { switch (pParams->videoType) { case MFX_CODEC_HEVC: case MFX_CODEC_AVC: case MFX_CODEC_JPEG: { pParams->bCalLat = true; if (!pParams->bIsMVC) break; } default: { PrintHelp(strInput[0], MSDK_STRING("-calc_latency mode is suppoted only for H.264 and JPEG codecs")); return MFX_ERR_UNSUPPORTED; } } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-async"))) { if(i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -async key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nAsyncDepth)) { PrintHelp(strInput[0], MSDK_STRING("async is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-di"))) { if(i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -di key")); return MFX_ERR_UNSUPPORTED; } msdk_char diMode[4] = {}; if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], diMode)) { PrintHelp(strInput[0], MSDK_STRING("deinterlace value is not set")); return MFX_ERR_UNSUPPORTED; } if (0 == msdk_strcmp(diMode, MSDK_CHAR("bob"))) { pParams->eDeinterlace = MFX_DEINTERLACING_BOB; } else if (0 == msdk_strcmp(diMode, MSDK_CHAR("adi"))) { pParams->eDeinterlace = MFX_DEINTERLACING_ADVANCED; } else { PrintHelp(strInput[0], MSDK_STRING("deinterlace value is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-no_gpu_copy"))) { pParams->gpuCopy = MFX_GPUCOPY_OFF; } #if !defined(_WIN32) && !defined(_WIN64) else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-threads_num"))) { if(i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -threads_num key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nThreadsNum)) { PrintHelp(strInput[0], MSDK_STRING("threads_num is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-threads_schedtype"))) { if(i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -threads_schedtype key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_thread_get_schedtype(strInput[++i], pParams->SchedulingType)) { PrintHelp(strInput[0], MSDK_STRING("threads_schedtype is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-threads_priority"))) { if(i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -threads_priority key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->Priority)) { PrintHelp(strInput[0], MSDK_STRING("threads_priority is invalid")); return MFX_ERR_UNSUPPORTED; } } #endif // #if !defined(_WIN32) && !defined(_WIN64) else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-f"))) { if(i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -f key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nMaxFPS)) { PrintHelp(strInput[0], MSDK_STRING("rendering frame rate is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scr:w"))) { if (i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -scr:w key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->scrWidth)) { PrintHelp(strInput[0], MSDK_STRING("screen width rate is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scr:h"))) { if (i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -scr:h key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->scrHeight)) { PrintHelp(strInput[0], MSDK_STRING("screen height is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-w"))) { if (i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -w key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->Width)) { PrintHelp(strInput[0], MSDK_STRING("width is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-h"))) { if (i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -h key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->Height)) { PrintHelp(strInput[0], MSDK_STRING("height is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-n"))) { if(i + 1 >= nArgNum) { PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -n key")); return MFX_ERR_UNSUPPORTED; } if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nFrames)) { PrintHelp(strInput[0], MSDK_STRING("rendering frame rate is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i420"))) { pParams->fourcc = MFX_FOURCC_NV12; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rgb4"))) { pParams->fourcc = MFX_FOURCC_RGB4; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-p010"))) { pParams->fourcc = MFX_FOURCC_P010; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-a2rgb10"))) { pParams->fourcc = MFX_FOURCC_A2RGB10; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-path"))) { i++; #if defined(_WIN32) || defined(_WIN64) msdk_char wchar[MSDK_MAX_FILENAME_LEN]; msdk_opt_read(strInput[i], wchar); std::wstring wstr(wchar); std::string str(wstr.begin(), wstr.end()); strcpy_s(pParams->pluginParams.strPluginPath, str.c_str()); #else msdk_opt_read(strInput[i], pParams->pluginParams.strPluginPath); #endif pParams->pluginParams.type = MFX_PLUGINLOAD_TYPE_FILE; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i:null"))) { ; } else // 1-character options { switch (strInput[i][1]) { case MSDK_CHAR('p'): if (++i < nArgNum) { if (MFX_ERR_NONE == ConvertStringToGuid(strInput[i], pParams->pluginParams.pluginGuid)) { pParams->pluginParams.type = MFX_PLUGINLOAD_TYPE_GUID; } else { PrintHelp(strInput[0], MSDK_STRING("Unknown options")); } } else { msdk_printf(MSDK_STRING("error: option '-p' expects an argument\n")); } break; case MSDK_CHAR('i'): if (++i < nArgNum) { msdk_opt_read(strInput[i], pParams->strSrcFile); } else { msdk_printf(MSDK_STRING("error: option '-i' expects an argument\n")); } break; case MSDK_CHAR('o'): if (++i < nArgNum) { pParams->mode = MODE_FILE_DUMP; msdk_opt_read(strInput[i], pParams->strDstFile); } else { msdk_printf(MSDK_STRING("error: option '-o' expects an argument\n")); } break; case MSDK_CHAR('?'): PrintHelp(strInput[0], NULL); return MFX_ERR_UNSUPPORTED; default: { std::basic_stringstream<msdk_char> stream; stream << MSDK_STRING("Unknown option: ") << strInput[i]; PrintHelp(strInput[0], stream.str().c_str()); return MFX_ERR_UNSUPPORTED; } } } } if (0 == msdk_strlen(pParams->strSrcFile) && MFX_CODEC_CAPTURE != pParams->videoType) { msdk_printf(MSDK_STRING("error: source file name not found")); return MFX_ERR_UNSUPPORTED; } if (MFX_CODEC_CAPTURE == pParams->videoType) { if (!pParams->scrWidth || !pParams->scrHeight) { msdk_printf(MSDK_STRING("error: for screen capture, width and height must be specified manually (-w and -h)")); return MFX_ERR_UNSUPPORTED; } } else if (pParams->scrWidth || pParams->scrHeight) { msdk_printf(MSDK_STRING("error: width and height parameters are supported only by screen capture decoder")); return MFX_ERR_UNSUPPORTED; } if ((pParams->mode == MODE_FILE_DUMP) && (0 == msdk_strlen(pParams->strDstFile))) { msdk_printf(MSDK_STRING("error: destination file name not found")); return MFX_ERR_UNSUPPORTED; } if (MFX_CODEC_MPEG2 != pParams->videoType && MFX_CODEC_AVC != pParams->videoType && MFX_CODEC_HEVC != pParams->videoType && MFX_CODEC_VC1 != pParams->videoType && MFX_CODEC_JPEG != pParams->videoType && MFX_CODEC_CAPTURE != pParams->videoType && CODEC_VP8 != pParams->videoType) { PrintHelp(strInput[0], MSDK_STRING("Unknown codec")); return MFX_ERR_UNSUPPORTED; } if (pParams->nAsyncDepth == 0) { pParams->nAsyncDepth = 4; //set by default; } return MFX_ERR_NONE; }
// This routine reads the registry to determine what type of device interfaces // we will be monitoring. The default PM GUID is ignored if present in the // registry and is always added last (so it's first in the list). BOOL DeviceListsInit(VOID) { BOOL fOk = TRUE; PDEVICE_LIST pdl; DWORD dwStatus; HKEY hk; TCHAR szBuf[MAX_PATH]; #ifndef SHIP_BUILD SETFNAME(_T("DeviceListsInit")); #endif // enumerate all the device classes StringCchPrintf(szBuf,_countof(szBuf), _T("%s\\Interfaces"), PWRMGR_REG_KEY); dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szBuf, 0, 0, &hk); if(dwStatus == ERROR_SUCCESS) { DWORD dwIndex = 0; do { DWORD cbValueName = dim(szBuf), dwType; GUID idInterface; dwStatus = RegEnumValue(hk, dwIndex, szBuf, &cbValueName, NULL, &dwType, NULL, NULL); if(dwStatus == ERROR_SUCCESS) { if(dwType != REG_SZ) { PMLOGMSG(ZONE_WARN, (_T("%s: invalid type for value '%s'\r\n"), pszFname, szBuf)); } else if(!ConvertStringToGuid(szBuf, &idInterface)) { PMLOGMSG(ZONE_WARN, (_T("%s: can't convert '%s' to GUID\r\n"), pszFname, szBuf)); } else if(idInterface == idGenericPMDeviceClass) { PMLOGMSG(ZONE_INIT, (_T("%s: default GUID found in registry as expected\r\n"), pszFname)); } else if((pdl = DeviceListCreate(&idInterface)) == NULL) { PMLOGMSG(ZONE_WARN, (_T("%s: DeviceListCreate() failed\r\n"), pszFname)); } else if(PlatformDeviceListInit(pdl) == FALSE) { PMLOGMSG(ZONE_WARN, (_T("%s: PlatformDeviceListInit() failed\r\n"), pszFname)); DeviceListDestroy(pdl); } else { // add the new entry to the list pdl->pNext = gpDeviceLists; gpDeviceLists = pdl; } // update the index dwIndex++; } } while(dwStatus == ERROR_SUCCESS); // check for abnormal termination of the loop if(dwStatus != ERROR_NO_MORE_ITEMS) { fOk = FALSE; } // close the registry handle RegCloseKey(hk); } // add the default list last if(fOk) { fOk = FALSE; pdl = DeviceListCreate(&idGenericPMDeviceClass); if(pdl != NULL) { if(PlatformDeviceListInit(pdl) == FALSE) { PMLOGMSG(ZONE_INIT || ZONE_WARN, (_T("%s: PlatformDeviceListInit() failed for default class\r\n"), pszFname)); DeviceListDestroy(pdl); } else { pdl->pNext = gpDeviceLists; gpDeviceLists = pdl; fOk = TRUE; } } } // clean up if necessary if(!fOk) { PMLOGMSG(ZONE_WARN, (_T("%s: error during list initialization\r\n"), pszFname)); while(gpDeviceLists != NULL) { pdl = gpDeviceLists; gpDeviceLists = pdl->pNext; pdl->pNext = NULL; DeviceListDestroy(pdl); } } return fOk; }
mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* pParams) { if (1 == nArgNum) { PrintHelp(strInput[0], NULL); return MFX_ERR_UNSUPPORTED; } MSDK_CHECK_POINTER(pParams, MFX_ERR_NULL_PTR); msdk_opt_read(MSDK_CPU_ROTATE_PLUGIN, pParams->strPluginDLLPath); // default implementation pParams->bUseHWLib = true; pParams->isV4L2InputEnabled = false; pParams->nNumFrames = 0; #if defined (ENABLE_V4L2_SUPPORT) pParams->MipiPort = -1; pParams->MipiMode = NONE; pParams->v4l2Format = NO_FORMAT; #endif // parse command line parameters for (mfxU8 i = 1; i < nArgNum; i++) { MSDK_CHECK_POINTER(strInput[i], MFX_ERR_NULL_PTR); if (MSDK_CHAR('-') != strInput[i][0]) { mfxStatus sts = StrFormatToCodecFormatFourCC(strInput[i], pParams->CodecId); if (sts != MFX_ERR_NONE) { PrintHelp(strInput[0], MSDK_STRING("Unknown codec")); return MFX_ERR_UNSUPPORTED; } if (!IsEncodeCodecSupported(pParams->CodecId)) { PrintHelp(strInput[0], MSDK_STRING("Unsupported codec")); return MFX_ERR_UNSUPPORTED; } if (pParams->CodecId == CODEC_MVC) { pParams->CodecId = MFX_CODEC_AVC; pParams->MVC_flags |= MVC_ENABLED; } continue; } // process multi-character options if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dstw"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nDstWidth)) { PrintHelp(strInput[0], MSDK_STRING("Destination picture Width is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dsth"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nDstHeight)) { PrintHelp(strInput[0], MSDK_STRING("Destination picture Height is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sw"))) { pParams->bUseHWLib = false; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-hw"))) { pParams->bUseHWLib = true; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-yuy2"))) { #if defined (ENABLE_V4L2_SUPPORT) pParams->v4l2Format = YUY2; #endif pParams->ColorFormat = MFX_FOURCC_YUY2; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-nv12"))) { pParams->ColorFormat = MFX_FOURCC_NV12; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tff"))) { pParams->nPicStruct = MFX_PICSTRUCT_FIELD_TFF; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bff"))) { pParams->nPicStruct = MFX_PICSTRUCT_FIELD_BFF; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bref"))) { pParams->nBRefType = MFX_B_REF_PYRAMID; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-nobref"))) { pParams->nBRefType = MFX_B_REF_OFF; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-idr_interval"))) { if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nIdrInterval)) { PrintHelp(strInput[0], MSDK_STRING("IdrInterval is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-angle"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nRotationAngle)) { PrintHelp(strInput[0], MSDK_STRING("Rotation Angle is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-opencl"))) { msdk_opt_read(MSDK_OCL_ROTATE_PLUGIN, pParams->strPluginDLLPath); pParams->nRotationAngle = 180; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-viewoutput"))) { if (!(MVC_ENABLED & pParams->MVC_flags)) { PrintHelp(strInput[0], MSDK_STRING("-viewoutput option is supported only when mvc codec specified")); return MFX_ERR_UNSUPPORTED; } pParams->MVC_flags |= MVC_VIEWOUTPUT; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-la"))) { pParams->nRateControlMethod = MFX_RATECONTROL_LA; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-lad"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); pParams->nRateControlMethod = MFX_RATECONTROL_LA; if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nLADepth)) { PrintHelp(strInput[0], MSDK_STRING("Look Ahead Depth is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-mss"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nMaxSliceSize)) { PrintHelp(strInput[0], MSDK_STRING("MaxSliceSize is invalid")); return MFX_ERR_UNSUPPORTED; } } #if D3D_SURFACES_SUPPORT else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d"))) { pParams->memType = D3D9_MEMORY; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d11"))) { pParams->memType = D3D11_MEMORY; } #endif #ifdef LIBVA_SUPPORT else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vaapi"))) { pParams->memType = D3D9_MEMORY; } #endif else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-async"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nAsyncDepth)) { PrintHelp(strInput[0], MSDK_STRING("Async Depth is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gpucopy::on"))) { pParams->gpuCopy = MFX_GPUCOPY_ON; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gpucopy::off"))) { pParams->gpuCopy = MFX_GPUCOPY_OFF; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cqp"))) { pParams->nRateControlMethod = MFX_RATECONTROL_CQP; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-qpi"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nQPI)) { PrintHelp(strInput[0], MSDK_STRING("Quantizer for I frames is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-qpp"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nQPP)) { PrintHelp(strInput[0], MSDK_STRING("Quantizer for P frames is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-qpb"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nQPB)) { PrintHelp(strInput[0], MSDK_STRING("Quantizer for B frames is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-qsv-ff"))) { pParams->enableQSVFF=true; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-num_slice"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nNumSlice)) { PrintHelp(strInput[0], MSDK_STRING("Number of slices is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-path"))) { i++; #if defined(_WIN32) || defined(_WIN64) msdk_char wchar[MSDK_MAX_FILENAME_LEN]; msdk_opt_read(strInput[i], wchar); std::wstring wstr(wchar); std::string str(wstr.begin(), wstr.end()); strcpy_s(pParams->pluginParams.strPluginPath, str.c_str()); #else msdk_opt_read(strInput[i], pParams->pluginParams.strPluginPath); #endif pParams->pluginParams.type = MFX_PLUGINLOAD_TYPE_FILE; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-re"))) { pParams->UseRegionEncode = true; } MOD_ENC_PARSE_INPUT #if defined (ENABLE_V4L2_SUPPORT) else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->DeviceName)) { PrintHelp(strInput[0], MSDK_STRING("Device name is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-uyvy"))) { pParams->v4l2Format = UYVY; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-p"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->MipiPort)) { PrintHelp(strInput[0], MSDK_STRING("Mipi-port is invalid")); return MFX_ERR_UNSUPPORTED; } } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-m"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->MipiModeName)) { PrintHelp(strInput[0], MSDK_STRING("Device name is invalid")); return MFX_ERR_UNSUPPORTED; } if(strcasecmp(pParams->MipiModeName,"STILL") == 0) pParams->MipiMode = STILL; else if(strcasecmp(pParams->MipiModeName,"VIDEO") == 0) pParams->MipiMode = VIDEO; else if(strcasecmp(pParams->MipiModeName,"PREVIEW") == 0) pParams->MipiMode = PREVIEW; else if(strcasecmp(pParams->MipiModeName,"CONTINUOUS") == 0) pParams->MipiMode = CONTINUOUS; else pParams->MipiMode = NONE; } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i::v4l2"))) { pParams->isV4L2InputEnabled = true; } #endif else // 1-character options { switch (strInput[i][1]) { case MSDK_CHAR('u'): if (++i < nArgNum) { pParams->nTargetUsage = StrToTargetUsage(strInput[i]); } else { msdk_printf(MSDK_STRING("error: option '-u' expects an argument\n")); } break; case MSDK_CHAR('w'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nWidth)) { PrintHelp(strInput[0], MSDK_STRING("Width is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-w' expects an argument\n")); } break; case MSDK_CHAR('h'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nHeight)) { PrintHelp(strInput[0], MSDK_STRING("Height is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-h' expects an argument\n")); } break; case MSDK_CHAR('f'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->dFrameRate)) { PrintHelp(strInput[0], MSDK_STRING("Frame Rate is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-f' expects an argument\n")); } break; case MSDK_CHAR('n'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nNumFrames)) { PrintHelp(strInput[0], MSDK_STRING("Number of frames to process is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-n' expects an argument\n")); } break; case MSDK_CHAR('b'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nBitRate)) { PrintHelp(strInput[0], MSDK_STRING("Bit Rate is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-b' expects an argument\n")); } break; case MSDK_CHAR('x'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nNumRefFrame)) { PrintHelp(strInput[0], MSDK_STRING("Ref Num is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-x' expects an argument\n")); } break; case MSDK_CHAR('g'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nGopPicSize)) { PrintHelp(strInput[0], MSDK_STRING("Gop Size is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-g' expects an argument\n")); } break; case MSDK_CHAR('r'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nGopRefDist)) { PrintHelp(strInput[0], MSDK_STRING("Ref Dist is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-r' expects an argument\n")); } break; case MSDK_CHAR('i'): if (++i < nArgNum) { msdk_opt_read(strInput[i], pParams->strSrcFile); if (MVC_ENABLED & pParams->MVC_flags) { pParams->srcFileBuff.push_back(strInput[i]); } } else { msdk_printf(MSDK_STRING("error: option '-i' expects an argument\n")); } break; case MSDK_CHAR('o'): if (++i < nArgNum) { pParams->dstFileBuff.push_back(strInput[i]); } else { msdk_printf(MSDK_STRING("error: option '-o' expects an argument\n")); } break; case MSDK_CHAR('q'): if (++i < nArgNum) { if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nQuality)) { PrintHelp(strInput[0], MSDK_STRING("Quality is invalid")); return MFX_ERR_UNSUPPORTED; } } else { msdk_printf(MSDK_STRING("error: option '-q' expects an argument\n")); } break; case MSDK_CHAR('p'): if (++i < nArgNum) { if (MFX_ERR_NONE == ConvertStringToGuid(strInput[i], pParams->pluginParams.pluginGuid)) { pParams->pluginParams.type = MFX_PLUGINLOAD_TYPE_GUID; } else { PrintHelp(strInput[0], MSDK_STRING("Unknown options")); } } else { msdk_printf(MSDK_STRING("error: option '-p' expects an argument\n")); } break; case MSDK_CHAR('?'): PrintHelp(strInput[0], NULL); return MFX_ERR_UNSUPPORTED; default: PrintHelp(strInput[0], MSDK_STRING("Unknown options")); } } } #if defined (ENABLE_V4L2_SUPPORT) if (pParams->isV4L2InputEnabled) { if (0 == msdk_strlen(pParams->DeviceName)) { PrintHelp(strInput[0], MSDK_STRING("Device Name not found")); return MFX_ERR_UNSUPPORTED; } if ((pParams->MipiPort > -1 && pParams->MipiMode == NONE) || (pParams->MipiPort < 0 && pParams->MipiMode != NONE)) { PrintHelp(strInput[0], MSDK_STRING("Invalid Mipi Configuration\n")); return MFX_ERR_UNSUPPORTED; } if (pParams->v4l2Format == NO_FORMAT) { PrintHelp(strInput[0], MSDK_STRING("NO input v4l2 format\n")); return MFX_ERR_UNSUPPORTED; } } #endif // check if all mandatory parameters were set if (0 == msdk_strlen(pParams->strSrcFile) && !pParams->isV4L2InputEnabled) { PrintHelp(strInput[0], MSDK_STRING("Source file name not found")); return MFX_ERR_UNSUPPORTED; }; if (pParams->dstFileBuff.empty()) { PrintHelp(strInput[0], MSDK_STRING("Destination file name not found")); return MFX_ERR_UNSUPPORTED; }; if (0 == pParams->nWidth || 0 == pParams->nHeight) { PrintHelp(strInput[0], MSDK_STRING("-w, -h must be specified")); return MFX_ERR_UNSUPPORTED; } if (MFX_CODEC_MPEG2 != pParams->CodecId && MFX_CODEC_AVC != pParams->CodecId && MFX_CODEC_JPEG != pParams->CodecId && MFX_CODEC_VP8 != pParams->CodecId && MFX_CODEC_HEVC != pParams->CodecId) { PrintHelp(strInput[0], MSDK_STRING("Unknown codec")); return MFX_ERR_UNSUPPORTED; } if (MFX_CODEC_JPEG != pParams->CodecId && pParams->ColorFormat == MFX_FOURCC_YUY2 && !pParams->isV4L2InputEnabled) { PrintHelp(strInput[0], MSDK_STRING("-yuy2 option is supported only for JPEG encoder")); return MFX_ERR_UNSUPPORTED; } // check parameters validity if (pParams->nRotationAngle != 0 && pParams->nRotationAngle != 180) { PrintHelp(strInput[0], MSDK_STRING("Angles other than 180 degrees are not supported.")); return MFX_ERR_UNSUPPORTED; // other than 180 are not supported } if (pParams->nQuality && (MFX_CODEC_JPEG != pParams->CodecId)) { PrintHelp(strInput[0], MSDK_STRING("-q option is supported only for JPEG encoder")); return MFX_ERR_UNSUPPORTED; } if ((pParams->nTargetUsage || pParams->nBitRate) && (MFX_CODEC_JPEG == pParams->CodecId)) { PrintHelp(strInput[0], MSDK_STRING("-u and -b options are supported only for H.264, MPEG2 and MVC encoders. For JPEG encoder use -q")); return MFX_ERR_UNSUPPORTED; } // set default values for optional parameters that were not set or were set incorrectly mfxU32 nviews = (mfxU32)pParams->srcFileBuff.size(); if ((nviews <= 1) || (nviews > 2)) { if (!(MVC_ENABLED & pParams->MVC_flags)) { pParams->numViews = 1; } else { PrintHelp(strInput[0], MSDK_STRING("Only 2 views are supported right now in this sample.")); return MFX_ERR_UNSUPPORTED; } } else { pParams->numViews = nviews; } if (MFX_TARGETUSAGE_BEST_QUALITY != pParams->nTargetUsage && MFX_TARGETUSAGE_BEST_SPEED != pParams->nTargetUsage) { pParams->nTargetUsage = MFX_TARGETUSAGE_BALANCED; } if (pParams->dFrameRate <= 0) { pParams->dFrameRate = 30; } // if no destination picture width or height wasn't specified set it to the source picture size if (pParams->nDstWidth == 0) { pParams->nDstWidth = pParams->nWidth; } if (pParams->nDstHeight == 0) { pParams->nDstHeight = pParams->nHeight; } // calculate default bitrate based on the resolution (a parameter for encoder, so Dst resolution is used) if (pParams->nBitRate == 0) { pParams->nBitRate = CalculateDefaultBitrate(pParams->CodecId, pParams->nTargetUsage, pParams->nDstWidth, pParams->nDstHeight, pParams->dFrameRate); } // if nv12 option wasn't specified we expect input YUV file in YUV420 color format if (!pParams->ColorFormat) { pParams->ColorFormat = MFX_FOURCC_YV12; } if (!pParams->nPicStruct) { pParams->nPicStruct = MFX_PICSTRUCT_PROGRESSIVE; } if ((pParams->nRateControlMethod == MFX_RATECONTROL_LA) && (!pParams->bUseHWLib)) { PrintHelp(strInput[0], MSDK_STRING("Look ahead BRC is supported only with -hw option!")); return MFX_ERR_UNSUPPORTED; } if ((pParams->nMaxSliceSize) && (!pParams->bUseHWLib)) { PrintHelp(strInput[0], MSDK_STRING("MaxSliceSize option is supported only with -hw option!")); return MFX_ERR_UNSUPPORTED; } if ((pParams->nMaxSliceSize) && (pParams->nNumSlice)) { PrintHelp(strInput[0], MSDK_STRING("-mss and -num_slice options are not compatible!")); return MFX_ERR_UNSUPPORTED; } if ((pParams->nRateControlMethod == MFX_RATECONTROL_LA) && (pParams->CodecId != MFX_CODEC_AVC)) { PrintHelp(strInput[0], MSDK_STRING("Look ahead BRC is supported only with H.264 encoder!")); return MFX_ERR_UNSUPPORTED; } if ((pParams->nMaxSliceSize) && (pParams->CodecId != MFX_CODEC_AVC)) { PrintHelp(strInput[0], MSDK_STRING("MaxSliceSize option is supported only with H.264 encoder!")); return MFX_ERR_UNSUPPORTED; } if (pParams->nLADepth && (pParams->nLADepth < 10 || pParams->nLADepth > 100)) { if ((pParams->nLADepth != 1) || (!pParams->nMaxSliceSize)) { PrintHelp(strInput[0], MSDK_STRING("Unsupported value of -lad parameter, must be in range [10, 100] or 1 in case of -mss option!")); return MFX_ERR_UNSUPPORTED; } } // not all options are supported if rotate plugin is enabled if (pParams->nRotationAngle == 180 && ( MFX_PICSTRUCT_PROGRESSIVE != pParams->nPicStruct || pParams->nDstWidth != pParams->nWidth || pParams->nDstHeight != pParams->nHeight || MVC_ENABLED & pParams->MVC_flags || pParams->nRateControlMethod == MFX_RATECONTROL_LA)) { PrintHelp(strInput[0], MSDK_STRING("Some of the command line options are not supported with rotation plugin!")); return MFX_ERR_UNSUPPORTED; } if (pParams->nAsyncDepth == 0) { pParams->nAsyncDepth = 4; //set by default; } // Ignoring user-defined Async Depth for LA if (pParams->nMaxSliceSize) { pParams->nAsyncDepth = 1; } if (pParams->nRateControlMethod == 0) { pParams->nRateControlMethod = MFX_RATECONTROL_CBR; } if(pParams->UseRegionEncode) { if(pParams->CodecId != MFX_CODEC_HEVC) { msdk_printf(MSDK_STRING("Region encode option is compatible with h265(HEVC) encoder only.\nRegion encoding is disabled\n")); pParams->UseRegionEncode=false; } if (pParams->nWidth != pParams->nDstWidth || pParams->nHeight != pParams->nDstHeight || pParams->nRotationAngle!=0) { msdk_printf(MSDK_STRING("Region encode option is not compatible with VPP processing.\nRegion encoding is disabled\n")); pParams->UseRegionEncode=false; } } return MFX_ERR_NONE; }
/** Function for 'setvar' command. @param[in] ImageHandle Handle to the Image (NULL if Internal). @param[in] SystemTable Pointer to the System Table (NULL if Internal). **/ SHELL_STATUS EFIAPI ShellCommandRunSetVar ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_STATUS ShellStatus; CONST CHAR16 *VariableName; CONST CHAR16 *Data; EFI_GUID Guid; CONST CHAR16 *StringGuid; UINT32 Attributes; UINT32 Attributes2; VOID *Buffer; UINTN Size; UINTN LoopVar; EFI_DEVICE_PATH_PROTOCOL *DevPath; ShellStatus = SHELL_SUCCESS; Status = EFI_SUCCESS; Buffer = NULL; Size = 0; Attributes = 0; DevPath = NULL; // // initialize the shell lib (we must be in non-auto-init...) // Status = ShellInitialize(); ASSERT_EFI_ERROR(Status); Status = CommandInit(); ASSERT_EFI_ERROR(Status); // // parse the command line // Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE); if (EFI_ERROR(Status)) { if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, ProblemParam); FreePool(ProblemParam); ShellStatus = SHELL_INVALID_PARAMETER; } else { ASSERT(FALSE); } } else { if (ShellCommandLineGetCount(Package) < 2) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; } else if (ShellCommandLineGetCount(Package) > 3) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; } else { VariableName = ShellCommandLineGetRawValue(Package, 1); Data = ShellCommandLineGetRawValue(Package, 2); if (!ShellCommandLineGetFlag(Package, L"-guid")){ CopyGuid(&Guid, &gEfiGlobalVariableGuid); } else { StringGuid = ShellCommandLineGetValue(Package, L"-guid"); Status = ConvertStringToGuid(StringGuid, &Guid); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, StringGuid); ShellStatus = SHELL_INVALID_PARAMETER; } } if (Data == NULL) { // // Display what's there // Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer); if (Status == EFI_BUFFER_TOO_SMALL) { Buffer = AllocateZeroPool(Size); Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer); } if (!EFI_ERROR(Status)&& Buffer != NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_PRINT), gShellDebug1HiiHandle, &Guid, VariableName, Size); for (LoopVar = 0 ; LoopVar < Size ; LoopVar++) { ShellPrintEx(-1, -1, L"%02x ", ((UINT8*)Buffer)[LoopVar]); } ShellPrintEx(-1, -1, L"\r\n"); } else { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_GET), gShellDebug1HiiHandle, &Guid, VariableName, Status); ShellStatus = SHELL_ACCESS_DENIED; } } else if (StrCmp(Data, L"=") == 0) { // // Delete what's there! // Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, 0, NULL); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status); ShellStatus = SHELL_ACCESS_DENIED; } else { ASSERT(ShellStatus == SHELL_SUCCESS); } } else { if (Data[0] == L'=') { Data++; } // // Change what's there // if (ShellCommandLineGetFlag(Package, L"-bs")) { Attributes |= EFI_VARIABLE_BOOTSERVICE_ACCESS; } if (ShellCommandLineGetFlag(Package, L"-rt")) { Attributes |= EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS; } if (ShellCommandLineGetFlag(Package, L"-nv")) { Attributes |= EFI_VARIABLE_NON_VOLATILE; } if (ShellIsHexOrDecimalNumber(Data, TRUE, FALSE)) { if (StrLen(Data) % 2 != 0) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellDebug1HiiHandle, Data); ShellStatus = SHELL_INVALID_PARAMETER; } else { // // arbitrary buffer // Buffer = AllocateZeroPool((StrLen(Data) / 2)); if (Buffer == NULL) { Status = EFI_OUT_OF_RESOURCES; } else { for (LoopVar = 0 ; LoopVar < (StrLen(Data) / 2) ; LoopVar++) { ((UINT8*)Buffer)[LoopVar] = (UINT8)(HexCharToUintn(Data[LoopVar*2]) * 16); ((UINT8*)Buffer)[LoopVar] = (UINT8)(((UINT8*)Buffer)[LoopVar] + HexCharToUintn(Data[LoopVar*2+1])); } Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, StrLen(Data) / 2, Buffer); } if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status); ShellStatus = SHELL_ACCESS_DENIED; } else { ASSERT(ShellStatus == SHELL_SUCCESS); } } } else if (StrnCmp(Data, L"\"", 1) == 0) { Size = 0; Attributes2 = 0; Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes2, &Size, Buffer); if (Status == EFI_BUFFER_TOO_SMALL) { Buffer = AllocateZeroPool(Size); Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes2, &Size, Buffer); if (Buffer != NULL) { FreePool(Buffer); } Attributes = Attributes2; } // // ascii text // Data++; Buffer = AllocateZeroPool(StrSize(Data) / 2); if (Buffer == NULL) { Status = EFI_OUT_OF_RESOURCES; } else { AsciiSPrint(Buffer, StrSize(Data) / 2, "%s", Data); ((CHAR8*)Buffer)[AsciiStrLen(Buffer)-1] = CHAR_NULL; Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, AsciiStrSize(Buffer)-sizeof(CHAR8), Buffer); } if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status); ShellStatus = SHELL_ACCESS_DENIED; } else { ASSERT(ShellStatus == SHELL_SUCCESS); } } else if (StrnCmp(Data, L"L\"", 2) == 0) { // // ucs2 text // Data++; Data++; Buffer = AllocateZeroPool(StrSize(Data)); if (Buffer == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellDebug1HiiHandle); ShellStatus = SHELL_OUT_OF_RESOURCES; } else { UnicodeSPrint(Buffer, StrSize(Data), L"%s", Data); ((CHAR16*)Buffer)[StrLen(Buffer)-1] = CHAR_NULL; Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, StrSize(Buffer)-sizeof(CHAR16), Buffer); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status); ShellStatus = SHELL_ACCESS_DENIED; } else { ASSERT(ShellStatus == SHELL_SUCCESS); } } } else if (StrnCmp(Data, L"--", 2) == 0) { // // device path in text format // Data++; Data++; DevPath = ConvertTextToDevicePath(Data); if (DevPath == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_DPFT), gShellDebug1HiiHandle, Status); ShellStatus = SHELL_INVALID_PARAMETER; } else { Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, GetDevicePathSize(DevPath), DevPath); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status); ShellStatus = SHELL_ACCESS_DENIED; } else { ASSERT(ShellStatus == SHELL_SUCCESS); } } } else { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Data); ShellStatus = SHELL_INVALID_PARAMETER; } } } ShellCommandLineFreeVarList (Package); } if (Buffer != NULL) { FreePool(Buffer); } if (DevPath != NULL) { FreePool(DevPath); } return (ShellStatus); }