NTSTATUS PciDtfDeviceGetInfo(IN WDFDEVICE Device, IN WDFREQUEST Request)
{
PCIDTF_DEV_INFO *ReqData;
ULONG Value, Length;
NTSTATUS Status = STATUS_SUCCESS;
__try {
Status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(PCIDTF_DEV_INFO),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveOutputBuffer", Status);
__leave;
}
Status = WdfDeviceQueryProperty(Device,
DevicePropertyBusNumber,
sizeof(Value), &Value, &Length);
if (!NT_SUCCESS(Status)) {
TRACE_ERR
("WdfDeviceQueryProperty(DevicePropertyBusNumber)",
Status);
__leave;
}
ReqData->bus = (UINT8) Value;
Status = WdfDeviceQueryProperty(Device,
DevicePropertyAddress,
sizeof(Value), &Value, &Length);
if (!NT_SUCCESS(Status)) {
TRACE_ERR
("WdfDeviceQueryProperty(DevicePropertyAddress)",
Status);
__leave;
}
ReqData->devfn = (UINT8) Value;
ReqData->reg_count = (int)
WdfCollectionGetCount(GetDeviceData(Device)->RegSpaces);
TRACE_MSG(TRACE_LEVEL_VERBOSE, TRACE_FLAG_QUEUE,
"bus=0x%X, devfn=0x%X, reg_count=%d\n", ReqData->bus,
ReqData->devfn, ReqData->reg_count);
WdfRequestSetInformation(Request, sizeof(PCIDTF_DEV_INFO));
}
__finally {
WdfRequestComplete(Request, Status);
}
return Status;
}
BOOL CreateD3D9DeviceData(IN LPDIRECT3D9_DISPLAYADAPTER pDisplayAdapter, IN LPD3D9_DEVICEDATA pDeviceData)
{
HDC hDC;
/* Test DC creation for the display device */
if (NULL == (hDC = CreateDCA(NULL, pDisplayAdapter->szDeviceName, NULL, NULL)))
{
DPRINT1("Could not create dc for display adapter: %s", pDisplayAdapter->szDeviceName);
return FALSE;
}
pDeviceData->hDC = hDC;
pDeviceData->DisplayGuid = pDisplayAdapter->DisplayGuid;
pDeviceData->DeviceType = D3DDEVTYPE_HAL;
lstrcpynA(pDeviceData->szDeviceName, pDisplayAdapter->szDeviceName, CCHDEVICENAME);
pDeviceData->szDeviceName[CCHDEVICENAME-1] = '\0';
if (pDisplayAdapter->bInUseFlag)
{
pDeviceData->D3D9Callbacks.DeviceType = D3DDEVTYPE_HAL;
}
else if (IsGDIDriver(hDC))
{
pDeviceData->D3D9Callbacks.DeviceType = D3DDEVTYPE_REF;
}
if (FALSE == GetDeviceData(pDeviceData))
{
DPRINT1("Could not get device data for display adapter: %s", pDisplayAdapter->szDeviceName);
return FALSE;
}
return TRUE;
}
NTSTATUS PciDtfDeviceFreeDma(IN WDFDEVICE Device, IN WDFREQUEST Request)
{
PDEVICE_DATA DeviceData = GetDeviceData(Device);
int *ID;
WDFCOMMONBUFFER CommonBuffer;
NTSTATUS Status = STATUS_SUCCESS;
__try {
Status = WdfRequestRetrieveInputBuffer(Request,
sizeof(int),
(PVOID *) & ID, NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveInputBuffer", Status);
__leave;
}
CommonBuffer = PciDtfCommonBufferFind(DeviceData, *ID, TRUE);
if (CommonBuffer == NULL) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
TRACE_MSG(TRACE_LEVEL_VERBOSE, TRACE_FLAG_QUEUE,
"Delete common buffer 0x%p (ID=%d)\n", CommonBuffer,
*ID);
WdfObjectDelete(CommonBuffer);
}
__finally {
WdfRequestComplete(Request, Status);
}
return Status;
}
//int CPROC CompressFrame( PCOMPRESS pCompress, POINTER *data, INDEX *len )
int CPROC CompressFrame( uintptr_t psv, PCAPTURE_DEVICE pDevice )
{
PCOMPRESS pCompress = (PCOMPRESS)psv;
int xerr;
Image frame;
GetDeviceData( pDevice, &frame, NULL );
{ // setup constant factors about encoding behavior
pCompress->xframe.version = XVID_VERSION;
//pCompress->xframe.general = 0;
pCompress->xframe.motion = 0; /*PMV_ADVANCEDDIAMOND16;*/
pCompress->xframe.quant = 0; //1-31 specify quantizer...
//pCompress->xframe.intra = -0; // 1- force keyframe, 0-force not keyframe
pCompress->xframe.quant_intra_matrix = NULL;
pCompress->xframe.quant_inter_matrix = NULL;
/* setup the input frame here... */
pCompress->xframe.type = XVID_TYPE_AUTO;
pCompress->xframe.input.csp = XVID_CSP_BGRA;
pCompress->xframe.input.plane[0] = frame->image;
pCompress->xframe.input.stride[0] = frame->pwidth*sizeof(CDATA);
if( !pCompress->xframe.bitstream )
{
pCompress->xframe.length = frame->pwidth * frame->height; //frame->width * frame->height * 4;
pCompress->xframe.bitstream = Allocate( frame->pwidth * frame->height );
}
}
pCompress->xstats.version = XVID_VERSION;
xerr = xvid_encore( pCompress->xparam.handle, XVID_ENC_ENCODE, &pCompress->xframe, &pCompress->xstats );
if(0)
lprintf( WIDE("stats! %d %d %d %d %d %d")
, xerr
, pCompress->xstats.length
, pCompress->xstats.hlength
, pCompress->xstats.kblks
, pCompress->xstats.mblks
, pCompress->xstats.ublks );
if( xerr < 0 || xerr > 512000 )
{
lprintf( WIDE("Resulting %d data was %p(%d)")
, xerr
, pCompress->xframe.bitstream
, pCompress->xframe.length );
}
MemCpy( pCompress->bitstream, pCompress->xframe.bitstream, xerr );
SetDeviceData( pDevice, pCompress->bitstream, xerr );
// at this point pCompress->xframe.intra 0 did not result in keyframe
// 1 is a keyframe (scene change) 2 is keyframe (max keyfram interval)
return 1;
}
NTSTATUS PciDtfDeviceReadWriteCfg(IN WDFDEVICE Device, IN WDFREQUEST Request,
IN BOOLEAN Read)
{
PDEVICE_DATA DeviceData = GetDeviceData(Device);
PCIDTF_CFG_DATA *ReqData;
NTSTATUS Status = STATUS_SUCCESS;
__try {
Status = WdfRequestRetrieveInputBuffer(Request,
sizeof(PCIDTF_CFG_DATA),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveInputBuffer", Status);
__leave;
}
if (Read) {
Status = WdfRequestRetrieveOutputBuffer(Request,
sizeof
(PCIDTF_CFG_DATA),
(PVOID *) &
ReqData, NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveOutputBuffer",
Status);
__leave;
}
Status =
PciDtfConfigRead(&DeviceData->BusIntf, ReqData->off,
ReqData->len, &ReqData->val);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("PciDtfConfigRead", Status);
__leave;
}
WdfRequestSetInformation(Request,
sizeof(PCIDTF_CFG_DATA));
} else {
Status = PciDtfConfigWrite(&DeviceData->BusIntf,
ReqData->off, ReqData->len,
ReqData->val);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("PciDtfConfigWrite", Status);
__leave;
}
}
}
__finally {
WdfRequestComplete(Request, Status);
}
return Status;
}
NTSTATUS PciDtfDeviceGetDma(IN WDFDEVICE Device, IN WDFREQUEST Request)
{
PDEVICE_DATA DeviceData = GetDeviceData(Device);
PCIDTF_DMA_INFO *ReqData;
WDFCOMMONBUFFER CommonBuffer;
NTSTATUS Status = STATUS_SUCCESS;
__try {
Status = WdfRequestRetrieveInputBuffer(Request,
sizeof(PCIDTF_DMA_INFO),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveInputBuffer", Status);
__leave;
}
Status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(PCIDTF_DMA_INFO),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveOutputBuffer", Status);
__leave;
}
CommonBuffer =
PciDtfCommonBufferFind(DeviceData, ReqData->id, FALSE);
if (CommonBuffer == NULL) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
ReqData->addr =
WdfCommonBufferGetAlignedLogicalAddress
(CommonBuffer).QuadPart;
ReqData->len = (int)WdfCommonBufferGetLength(CommonBuffer);
WdfRequestSetInformation(Request, sizeof(PCIDTF_DMA_INFO));
}
__finally {
WdfRequestComplete(Request, Status);
}
return Status;
}
NTSTATUS PciDtfDeviceReadWriteDma(IN WDFDEVICE Device, IN WDFREQUEST Request,
IN BOOLEAN Read)
{
PDEVICE_DATA DeviceData = GetDeviceData(Device);
PCIDTF_DMA_DATA *ReqData;
WDFCOMMONBUFFER CommonBuffer;
NTSTATUS Status = STATUS_SUCCESS;
__try {
Status = WdfRequestRetrieveInputBuffer(Request,
sizeof(PCIDTF_DMA_DATA),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveInputBuffer", Status);
__leave;
}
TRACE_MSG(TRACE_LEVEL_VERBOSE, TRACE_FLAG_QUEUE,
"id=%d, off=%d, len=%d, buf=0x%p, read=%u\n",
ReqData->id, ReqData->off, ReqData->len, ReqData->buf,
Read);
CommonBuffer = PciDtfCommonBufferFind(DeviceData,
ReqData->id, FALSE);
if (CommonBuffer == NULL) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
Status = PciDtfDmaReadWrite(ReqData,
WdfCommonBufferGetAlignedVirtualAddress
(CommonBuffer),
(ULONG) WdfCommonBufferGetLength
(CommonBuffer), Read);
}
__finally {
WdfRequestComplete(Request, Status);
}
return Status;
}
NTSTATUS PciDtfDeviceAllocDma(IN WDFDEVICE Device, IN WDFREQUEST Request)
{
PDEVICE_DATA DeviceData = GetDeviceData(Device);
PCIDTF_DMA_INFO *ReqData;
WDF_OBJECT_ATTRIBUTES ObjectAttributes;
WDFCOMMONBUFFER CommonBuffer = NULL;
PCOMMON_BUFFER_DATA CommonBufferData;
NTSTATUS Status = STATUS_SUCCESS;
__try {
Status = WdfRequestRetrieveInputBuffer(Request,
sizeof(PCIDTF_DMA_INFO),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveInputBuffer", Status);
__leave;
}
Status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(PCIDTF_DMA_INFO),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveOutputBuffer", Status);
__leave;
}
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&ObjectAttributes,
COMMON_BUFFER_DATA);
Status = WdfCommonBufferCreate(DeviceData->DmaEnabler,
ReqData->len, &ObjectAttributes,
&CommonBuffer);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfCommonBufferCreate", Status);
__leave;
}
CommonBufferData = GetCommonBufferData(CommonBuffer);
CommonBufferData->ID = PciDtfCommonBufferAssignId(DeviceData);
Status = WdfCollectionAdd(DeviceData->CommonBuffers,
CommonBuffer);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfCollectionAdd", Status);
__leave;
}
ReqData->id = CommonBufferData->ID;
ReqData->addr =
WdfCommonBufferGetAlignedLogicalAddress
(CommonBuffer).QuadPart;
WdfRequestSetInformation(Request, sizeof(PCIDTF_DMA_INFO));
TRACE_MSG(TRACE_LEVEL_VERBOSE, TRACE_FLAG_QUEUE,
"va 0x%p, pa 0x%llX, len 0x%X\n",
WdfCommonBufferGetAlignedVirtualAddress(CommonBuffer),
WdfCommonBufferGetAlignedLogicalAddress
(CommonBuffer).QuadPart,
WdfCommonBufferGetLength(CommonBuffer));
}
__finally {
if (!NT_SUCCESS(Status) && CommonBuffer != NULL) {
WdfObjectDelete(CommonBuffer);
}
WdfRequestComplete(Request, Status);
}
return Status;
}
// returns FALSE on END command, TRUE otherwise
bool tScriptState::ExecuteCommand(tCommand& cmd)
{
bool bContinue = TRUE;
switch(cmd.cmdId)
{
case cmdLabel:
break;
case cmdGoto:
{
ULONG step;
const tParameter *pParam = cmd.params.GetAt(0);
if (!FindLabelByName(*pParam, &step))
{
FailCase("Can't find label %s", (LPCSTR)pParam->String());
}
else
{
currentCommandIndex = step;
}
}
break;
case cmdIf:
{
bool bTrue = EvaluateCondition(cmd.params[0]->String());
if (!bTrue)
{
currentCommandIndex = cmd.elseStepForIf;
}
}
break;
case cmdEnd:
bContinue = FALSE;
break;
case cmdSet:
{
ULONG data;
ULONG value = cmd.params[1]->Value();
if (!GetVariable(cmd.params[0]->String(), data) || data != value)
{
data = value;
SetVariable(cmd.params[0]->String(), data);
}
}
break;
case cmdAdd:
{
ULONG data;
if (GetVariable(cmd.params[0]->String(), data))
{
data += cmd.params[1]->Value();
SetVariable(cmd.params[0]->String(), data);
}
else
{
FailCase("Can't add %s", cmd.params[0]->String());
}
}
break;
case cmdPrepare:
{
ULONG data;
if (GetVariable("use_merged_buffers", data))
bUseMergedBuffers = !!data;
if (GetVariable("use_published_events", data))
bUsePublishedIndices = !!data;
if (GetVariable("use_msix", data))
bMSIXUsed = !!data;
SimulationPrepare();
}
break;
case cmdTxAsync:
{
bAsyncTransmit = !!cmd.params[0]->Value();
}
break;
case cmdSend:
{
AddTxBuffers(cmd.params[0]->Value(), cmd.params[1]->Value());
}
break;
case cmdTxComplete:
{
CompleteTx((int)cmd.params[0]->Value());
}
break;
case cmdTxGet:
{
GetTxBuffer(cmd.params[0]->Value());
}
break;
case cmdRxReturn:
{
ReturnRxBuffer(cmd.params[0]->Value());
}
break;
case cmdRxReceive:
{
RxReceivePacket((UCHAR)cmd.params[0]->Value());
}
break;
case cmdDataGet:
{
UCHAR offset, val, res;
offset = (UCHAR)cmd.params[0]->Value();
val = (UCHAR)cmd.params[1]->Value();
res = GetDeviceData(offset);
if (res != val)
{
FailCase("cmdDataGet(%d) = %d, expected %d", offset, res, val);
}
}
break;
case cmdDataSet:
{
UCHAR offset, val;
offset = (UCHAR)cmd.params[0]->Value();
val = (UCHAR)cmd.params[1]->Value();
SetDeviceData(offset, val);
}
break;
case cmdRxRestart:
{
BOOLEAN bExpected = (BOOLEAN)cmd.params[0]->Value();
BOOLEAN b = RxRestart();
if (b != bExpected)
{
FailCase("RxRestart: %d, expected %d", b, bExpected);
}
}
break;
case cmdTxRestart:
{
BOOLEAN bExpected = (BOOLEAN)cmd.params[0]->Value();
BOOLEAN b = TxRestart();
if (b != bExpected)
{
FailCase("TxRestart: %d, expected %d", b, bExpected);
}
}
break;
case cmdTxEnableInterrupt:
{
TxEnableInterrupt();
}
break;
case cmdTxDisableInterrupt:
{
TxDisableInterrupt();
}
break;
case cmdRxEnableInterrupt:
{
RxEnableInterrupt();
}
break;
case cmdRxDisableInterrupt:
{
RxDisableInterrupt();
}
break;
case cmdRxGet:
{
ULONG len;
GetRxBuffer(&len);
}
break;
case cmdControlRxMode:
{
SetRxMode((UCHAR)cmd.params[0]->Value(), cmd.params[1]->Value() != 0);
}
break;
case cmdControlVlanAdd:
{
USHORT us = (USHORT)cmd.params[0]->Value();
VlansAdd(&us, 1);
}
break;
case cmdControlVlanDel:
{
USHORT us = (USHORT)cmd.params[0]->Value();
VlansDel(&us, 1);
}
break;
case cmdControlMacTable:
{
SetMacAddresses(cmd.params[0]->Value());
}
default:
result = 1;
break;
}
return bContinue;
}
DWORD
ProcessSessionThreadRequest(SessionInfo* session_info)
{
MMRESULT result = MMSYSERR_NOERROR;
switch ( session_info->thread.function )
{
case WODM_WRITE :
{
result = QueueWaveBuffer(session_info,
(LPWAVEHDR) session_info->thread.parameter);
break;
}
case WODM_RESET :
{
/* TODO */
break;
}
case WODM_PAUSE :
{
/* TODO */
break;
}
case WODM_RESTART :
{
/* TODO */
break;
}
case WODM_GETPOS :
{
/* TODO */
break;
}
case WODM_SETPITCH :
{
result = SetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_SET_PITCH,
(PBYTE) session_info->thread.parameter,
sizeof(DWORD));
break;
}
case WODM_GETPITCH :
{
result = GetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_GET_PITCH,
(PBYTE) session_info->thread.parameter,
sizeof(DWORD));
break;
}
case WODM_SETVOLUME :
{
break;
}
case WODM_GETVOLUME :
{
#if 0
result = GetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_GET_VOLUME,
(PBYTE) session_info->thread.parameter,);
#endif
break;
}
case WODM_SETPLAYBACKRATE :
{
result = SetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_SET_PLAYBACK_RATE,
(PBYTE) session_info->thread.parameter,
sizeof(DWORD));
break;
}
case WODM_GETPLAYBACKRATE :
{
result = GetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_GET_PLAYBACK_RATE,
(PBYTE) session_info->thread.parameter,
sizeof(DWORD));
break;
}
case WODM_CLOSE :
{
DPRINT("Thread was asked if OK to close device\n");
if ( session_info->wave_queue != NULL )
result = WAVERR_STILLPLAYING;
else
result = MMSYSERR_NOERROR;
break;
}
case DRVM_TERMINATE :
{
DPRINT("Terminating thread...\n");
result = MMSYSERR_NOERROR;
break;
}
default :
{
DPRINT("INVALID FUNCTION\n");
result = MMSYSERR_ERROR;
break;
}
}
/* We're done with the function now */
return result;
}
