able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/wdm/capture/mini/1394dcam/dcampkt.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

2686 lines
81 KiB
C
Raw Blame History

//===========================================================================
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE.
//
// Copyright (c) 1996 - 2000 Microsoft Corporation. All Rights Reserved.
//
//===========================================================================
/*++
Module Name:
dcampkt.c
Abstract:
Stream class based WDM driver for 1934 Desktop Camera.
This file contains code to handle the stream class packets.
Author:
Shaun Pierce 25-May-96
Modified:
Yee J. Wu 15-Oct-97
Environment:
Kernel mode only
Revision History:
--*/
#include "strmini.h"
#include "ksmedia.h"
#include "1394.h"
#include "wdm.h" // for DbgBreakPoint() defined in dbg.h
#include "dbg.h"
#include "dcamdef.h"
#include "dcampkt.h"
#include "strmdata.h" // stream format and data ranges; static data
#include "capprop.h" // Video and camera property function prototype
#define WAIT_FOR_SLOW_DEVICE
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, DCamProcessPnpIrp)
#pragma alloc_text(PAGE, DCamGetStreamInfo)
#pragma alloc_text(PAGE, DCamFreeIsochResource)
#pragma alloc_text(PAGE, InitializeStreamExtension)
#pragma alloc_text(PAGE, DCamOpenStream)
#pragma alloc_text(PAGE, DCamCloseStream)
#pragma alloc_text(PAGE, AdapterCompareGUIDsAndFormatSize)
#pragma alloc_text(PAGE, AdapterVerifyFormat)
#pragma alloc_text(PAGE, AdapterFormatFromRange)
#pragma alloc_text(PAGE, VideoGetProperty)
#pragma alloc_text(PAGE, VideoGetState)
#pragma alloc_text(PAGE, VideoStreamGetConnectionProperty)
#pragma alloc_text(PAGE, VideoStreamGetDroppedFramesProperty)
#pragma alloc_text(PAGE, VideoIndicateMasterClock)
#pragma alloc_text(PAGE, DCamReceivePacket)
#pragma alloc_text(PAGE, DCamChangePower)
#endif
void
tmGetStreamTime(
IN PHW_STREAM_REQUEST_BLOCK Srb,
PSTREAMEX pStrmEx,
ULONGLONG * ptmStream)
/*++
Routine Description:
Query the current time used to timestamp the frame or calculating the dropped frame.
This is used in IsochCallback so must be paged in always.
Arguments:
Srb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
HW_TIME_CONTEXT TimeContext;
TimeContext.HwDeviceExtension = (PVOID) Srb->HwDeviceExtension;
TimeContext.HwStreamObject = Srb->StreamObject;
TimeContext.Function = TIME_GET_STREAM_TIME;
TimeContext.Time = 0;
TimeContext.SystemTime = 0;
StreamClassQueryMasterClockSync(
pStrmEx->hMasterClock,
&TimeContext);
*ptmStream = TimeContext.Time;
}
BOOL
DCamAllocateIrbAndIrp(
PIRB * ppIrb,
PIRP * ppIrp,
CCHAR StackSize
)
{
// Allocate Irb and Irp
*ppIrb = ExAllocatePoolWithTag(NonPagedPool, sizeof(IRB), 'macd');
if(!*ppIrb) {
return FALSE;
}
*ppIrp = IoAllocateIrp(StackSize, FALSE);
if(!*ppIrp) {
ExFreePool(*ppIrb);
*ppIrb = NULL;
return FALSE;
}
// Initialize IRB
RtlZeroMemory(*ppIrb, sizeof(IRB));
return TRUE;
}
BOOL
DCamAllocateIrbIrpAndContext(
PDCAM_IO_CONTEXT * ppDCamIoContext,
PIRB * ppIrb,
PIRP * ppIrp,
CCHAR StackSize
)
{
// Allocate DCamIoContext
*ppDCamIoContext = ExAllocatePoolWithTag(NonPagedPool, sizeof(DCAM_IO_CONTEXT), 'macd');
if(!*ppDCamIoContext) {
return FALSE;
}
// Allocate Irb and Irp
*ppIrb = ExAllocatePoolWithTag(NonPagedPool, sizeof(IRB), 'macd');
if(!*ppIrb) {
ExFreePool(*ppDCamIoContext);
*ppDCamIoContext = NULL;
return FALSE;
}
*ppIrp = IoAllocateIrp(StackSize, FALSE);
if(!*ppIrp) {
ExFreePool(*ppDCamIoContext);
*ppDCamIoContext = NULL;
ExFreePool(*ppIrb);
*ppIrb = NULL;
return FALSE;
}
// Initialize this context
RtlZeroMemory(*ppDCamIoContext, sizeof(DCAM_IO_CONTEXT));
(*ppDCamIoContext)->dwSize = sizeof(DCAM_IO_CONTEXT);
(*ppDCamIoContext)->pIrb = *ppIrb;
// Initialize IRB
RtlZeroMemory(*ppIrb, sizeof(IRB));
return TRUE;
}
void
DCamFreeIrbIrpAndContext(
PDCAM_IO_CONTEXT pDCamIoContext,
PIRB pIrb,
PIRP pIrp
)
{
if(pIrp)
IoFreeIrp(pIrp);
if(pIrb)
ExFreePool(pIrb);
if(pDCamIoContext)
ExFreePool(pDCamIoContext);
}
BOOL
DCamIsoEnable(
PIRB pIrb,
PDCAM_EXTENSION pDevExt,
BOOL Enable
)
/*
Start or start isoch transmission by setting the ISOEnable bit.
TRUE: Start transmission;
FALSE: Stop transmission.
*/
{
BOOL EnableVerify;
DCamRegArea RegArea;
NTSTATUS Status;
LARGE_INTEGER stableTime;
LONG lRetries = MAX_READ_REG_RETRIES;
do {
RegArea.AsULONG = (Enable ? START_ISOCH_TRANSMISSION : STOP_ISOCH_TRANSMISSION);
Status = DCamWriteRegister(pIrb, pDevExt, FIELDOFFSET(CAMERA_REGISTER_MAP, IsoEnable), RegArea.AsULONG);
EnableVerify = DCamDeviceInUse(pIrb, pDevExt);
if(!NT_SUCCESS(Status) || EnableVerify != Enable) {
ERROR_LOG(("\'DCAmIsoEnable: St:%x; Enable:%d vs EnableVerify:%d\n", Status, Enable, EnableVerify));
if(lRetries >= 1) {
stableTime.LowPart = DCAM_REG_STABLE_DELAY;
stableTime.HighPart = -1;
KeDelayExecutionThread(KernelMode, TRUE, &stableTime);
ERROR_LOG(("\'DCamIsoEnable: delayed and try again...\n"))
}
}
} while (--lRetries > 0 && (!NT_SUCCESS(Status) || (EnableVerify != Enable)) );
return (EnableVerify == Enable);
}
void
DCamProcessPnpIrp(
IN PHW_STREAM_REQUEST_BLOCK Srb,
PIO_STACK_LOCATION IrpStack,
PDCAM_EXTENSION pDevExt
)
/*++
Routine Description:
Process PnP Irp.
Arguments:
Srb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
NTSTATUS Status, StatusWait;
PIRB pIrb;
PIRP pIrp;
PSTREAMEX pStrmEx;
PAGED_CODE();
switch (IrpStack->MinorFunction) {
#if 1
case IRP_MN_QUERY_POWER:
pStrmEx = (PSTREAMEX) pDevExt->pStrmEx;
ERROR_LOG(("IRP_MN_QUERY_POWER: pStrmEx:%x\n", pStrmEx));
if(!pStrmEx) {
Srb->Status = STATUS_SUCCESS;
break;
}
if(pStrmEx->KSState == KSSTATE_PAUSE || pStrmEx->KSState == KSSTATE_RUN) {
ERROR_LOG(("Does not support hibernation while streaming!\n"));
Srb->Status = STATUS_NOT_SUPPORTED;
} else {
ERROR_LOG(("OK to hibernation if not streaming\n"));
Srb->Status = STATUS_SUCCESS;
}
break;
#endif
case IRP_MN_BUS_RESET:
//
// We will realocate the resource (bandwith and channel) in IRQL PASSIVE level.
//
Srb->Status = STATUS_SUCCESS;
Status = STATUS_SUCCESS;
//
// The generation count is updated in the bus reset callback notification only.
// Continue iff the generation count has been updated.
// Else, we are assuming another bus reset has occurred,
// and we will pass to us later.
//
if(pDevExt->CurrentGeneration != *((PULONG) &IrpStack->Parameters.Others.Argument4)) {
ERROR_LOG(("DCamProcessPnpIrp: Generation count old (%d) != new (%d); STOP!\n",
pDevExt->CurrentGeneration, *((PULONG) &IrpStack->Parameters.Others.Argument4)) );
break;
}
pStrmEx = (PSTREAMEX) pDevExt->pStrmEx;
DbgMsg2(("\'%d:%s) SonyDCamProcessPnpIrp: pDevExt %x; pStrmEx %x; CurGen %d\n",
pDevExt->idxDev, pDevExt->pchVendorName, pDevExt, pStrmEx, pDevExt->CurrentGeneration));
//
// If the stream was open (pStrmEx != NULL && pStrmEx->pVideoInfoHeader != NULL);
// We need to ask controller to allocate bandwidth and channel.
//
if(pStrmEx &&
pStrmEx->pVideoInfoHeader != NULL) {
DbgMsg2(("\'%d:%s) DCamProcessPnpIrp: Stream was open so re-allocate resource.\n", pDevExt->idxDev, pDevExt->pchVendorName));
// Allocate Irb
pIrb = ExAllocatePoolWithTag(NonPagedPool, sizeof(IRB), 'macd');
if(!pIrb) {
ERROR_LOG(("\'DCamProcessPnpIrp: allocate IRB failed; insufficient resource.\n"));
Srb->Status = STATUS_INSUFFICIENT_RESOURCES;
break;
} else {
ULONG ulChannel;
HANDLE hResource;
pIrp = IoAllocateIrp(pDevExt->BusDeviceObject->StackSize, FALSE);
if(!pIrp) {
ExFreePool(pIrb);
Srb->Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlZeroMemory(pIrb, sizeof(IRB));
//
// Bus reset will free the bandwidth but not the bandwidth structure allocated by the lower driver
//
if (pDevExt->hBandwidth) {
DbgMsg2(("\'DCamProcessPnpIrp: Attempt to free ->hBandwidth\n"));
pIrb->FunctionNumber = REQUEST_ISOCH_FREE_BANDWIDTH;
pIrb->Flags = 0;
pIrb->u.IsochFreeBandwidth.hBandwidth = pDevExt->hBandwidth;
Status = DCamSubmitIrpSynch(pDevExt, pIrp, pIrb);
if (Status) {
ERROR_LOG(("DCamProcessPnpIrp: Error %x while trying to free Isoch bandwidth\n", Status));
ASSERT(Status == STATUS_SUCCESS || Status == STATUS_INVALID_GENERATION);
}
pDevExt->hBandwidth = NULL;
}
//
// Before we assign the new hResource, we wait for it attaching buffer to complete.
// For buffer that completed with previous hResource,
// It will complete with error ?
//
StatusWait = KeWaitForSingleObject( &pStrmEx->hMutex, Executive, KernelMode, FALSE, 0 );
//
// Reallocate bandwidth and channel, and resource if necessary.
// IF THIS FAIL, we are consider illegally streaming, and need to STOP streaming.
//
ulChannel = pDevExt->IsochChannel;
hResource = pDevExt->hResource;
Status = DCamAllocateIsochResource(pDevExt, pIrb, FALSE);
if(Status) {
ERROR_LOG(("\'%d:%s) DCamProcessPnpIrp: Re-AllocateIsochResource failed! Status=%x; Treat as device removed.\n\n",
pDevExt->idxDev, pDevExt->pchVendorName, Status));
ASSERT(Status == STATUS_SUCCESS);
//
// No resource so let's treat this situation as
// Device has been removed because there is no
// way to restart this.
// This will stop future SRB_READ until stream is STOP and RUN again.
//
pDevExt->bDevRemoved = TRUE;
Srb->Status = STATUS_INSUFFICIENT_RESOURCES;
//
// Stop tranmission so it will not send data to the old channel,
// which might be "owned" by other device.
//
if(pStrmEx->KSState == KSSTATE_RUN) {
// Disable EnableISO
DCamIsoEnable(pIrb, pDevExt, FALSE);
}
KeReleaseMutex(&pStrmEx->hMutex, FALSE);
ExFreePool(pIrb);
IoFreeIrp(pIrp);
return;
}
//
// If channel number change due to bus reset, we must
// - continue to blocking incoming SRB_READ (with mutex)
// - if RUN state, stop transmission
// - detach all pending buffer(s)
// - free "stale" isoch resource
// - if RUN state, program device to use the new channel
// - if RUN state, restart transmission
//
if(pDevExt->IsochChannel != ISOCH_ANY_CHANNEL &&
ulChannel != pDevExt->IsochChannel) {
//
// Stop tranmission so it will not send data to the old channel,
// which might be "owned" by other device.
//
if(pStrmEx->KSState == KSSTATE_RUN) {
// Disable EnableISO
DCamIsoEnable(pIrb, pDevExt, FALSE);
}
//
// Detach pending packets using the hOldRources and reattached using the new hResource
// Note: incoming SRB_READ is block right now.
// free old resource after all pending reads are detached.
//
if(pDevExt->PendingReadCount > 0) {
Status = DCamReSubmitPacket(hResource, pDevExt, pStrmEx, pDevExt->PendingReadCount);
}
//
// Free "stale" isoch resource
//
if(pDevExt->hResource != hResource) {
DbgMsg2(("DCamReSubmitPacket: Attempt to free hStaleResource %x\n", hResource));
pIrb->FunctionNumber = REQUEST_ISOCH_FREE_RESOURCES;
pIrb->Flags = 0;
pIrb->u.IsochFreeResources.hResource = hResource;
Status = DCamSubmitIrpSynch(pDevExt, pIrp, pIrb);
if (Status) {
ERROR_LOG(("\'DCamFreeIsochResource: Error %x while trying to free Isoch resources\n\n", Status));
ASSERT(Status == STATUS_SUCCESS);
}
}
//
// Getting ready to accept callback
//
pDevExt->bStopIsochCallback = FALSE;
//
// Restore to its initial Streaming state
// mainly, programming device.
//
DCamSetKSStateInitialize(pDevExt);
}
KeReleaseMutex(&pStrmEx->hMutex, FALSE);
ExFreePool(pIrb);
IoFreeIrp(pIrp);
}
}
if(Status == STATUS_SUCCESS) {
//
// Set to last saved configuration
//
SetCurrentDevicePropertyValues(pDevExt, (PIRB) Srb->SRBExtension);
}
DbgMsg2(("\'DCamProcessPnpIrp, IRP_MN_BUS_RESET: Done, Status %x\n", Status));
break;
case IRP_MN_QUERY_CAPABILITIES:
ERROR_LOG(("\'SonyDCamProcessPnpIrp: IRP_MN_QUERY_CAPABILITIES: Srb->Status = STATUS_NOT_IMPLEMENTED.\n"));
default:
Srb->Status = STATUS_NOT_IMPLEMENTED;
break;
}
}
VOID
DCamChangePower(
IN PHW_STREAM_REQUEST_BLOCK pSrb
)
/*++
Routine Description:
Process chnaging this device's power state.
Arguments:
Srb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
PDCAM_EXTENSION pDevExt;
PSTREAMEX pStrmEx;
PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(pSrb->Irp);
DEVICE_POWER_STATE DevicePowerState = pSrb->CommandData.DeviceState;
PAGED_CODE();
pDevExt = (PDCAM_EXTENSION) pSrb->HwDeviceExtension;
DbgMsg2(("\'DCamChangePower: pSrb=%x; pDevExt=%x\n", pSrb, pDevExt));
ASSERT(pDevExt != NULL);
if(!pDevExt) {
pSrb->Status = STATUS_INVALID_PARAMETER;
ERROR_LOG(("DCamChangePower: pDevExt is NULL!\n"));
return;
}
pStrmEx = (PSTREAMEX) pDevExt->pStrmEx;
if (pStrmEx ==NULL) {
pSrb->Status = STATUS_SUCCESS;
pDevExt->CurrentPowerState = DevicePowerState;
DbgMsg2(("DCamChangePower: pStrmEx is NULL => Stream is not open. That is Ok!!\n"));
return;
}
//
// We can honor power state change:
//
// D0: device is on and running
// D1,D2: not implemented.
// D3: device is off and not running. Device context is lost.
// Power can be removed from the device.
// when power is back on, we will get a bus reset.
//
// (0) Remove DontSuspendIfStreamsAreRunning from INF
// save current state.
// (1) ->D3, to PAUSE/STOP state (depends on if pending buffers can be kept by its lower driver)
// (2) ->D0, to restore saved state
//
// We can do the above but we do not know at this point
// how our client application react
//
if(IrpStack->MinorFunction == IRP_MN_SET_POWER) {
DbgMsg2(("DCamChangePower: changin power state from %d to %d.\n", pDevExt->CurrentPowerState, DevicePowerState));
pSrb->Status = STATUS_SUCCESS;
if(pDevExt->CurrentPowerState != DevicePowerState) {
switch (DevicePowerState) {
case PowerDeviceD3: // D0->D3: save state, stop streaming and Sleep
if( pDevExt->CurrentPowerState == PowerDeviceD0 ) {
DbgMsg1(("DCamChangePower: Switching from D0 to D3; Save current state.\n"));
// Save current state to be restored when awake
pStrmEx->KSSavedState = pStrmEx->KSState;
}
break;
case PowerDeviceD0: // to Wakeup, restore state and running
if( pDevExt->CurrentPowerState == PowerDeviceD3 ) {
DbgMsg1(("DCamChangePower: Switching from D3 to D0; restore state.\n"));
pStrmEx->KSState = pStrmEx->KSSavedState;
}
break;
// These state are not defined and noe used.
case PowerDeviceD1:
case PowerDeviceD2:
default:
ERROR_LOG(("DCamChangePower: Invalid PowerState %d\n", DevicePowerState));
pSrb->Status = STATUS_INVALID_PARAMETER;
break;
}
}
if(pSrb->Status == STATUS_SUCCESS)
pDevExt->CurrentPowerState = DevicePowerState;
} else {
pSrb->Status = STATUS_NOT_IMPLEMENTED;
}
}
VOID
DCamGetStreamInfo(
IN PHW_STREAM_REQUEST_BLOCK Srb
)
/*++
Routine Description:
Returns the information of all streams that are supported by the driver
Arguments:
Srb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
//
// pick up the pointer to the stream information data structure
//
PIRB pIrb;
PHW_STREAM_HEADER StreamHeader = &(Srb->CommandData.StreamBuffer->StreamHeader);
PDCAM_EXTENSION pDevExt = (PDCAM_EXTENSION) Srb->HwDeviceExtension;
PHW_STREAM_INFORMATION StreamInfo = &(Srb->CommandData.StreamBuffer->StreamInfo);
PAGED_CODE();
pIrb = (PIRB) Srb->SRBExtension;
//
// set number of streams
//
ASSERT (Srb->NumberOfBytesToTransfer >=
sizeof (HW_STREAM_HEADER) +
sizeof (HW_STREAM_INFORMATION));
//
// initialize stream header
//
RtlZeroMemory(StreamHeader,
sizeof (HW_STREAM_HEADER) +
sizeof (HW_STREAM_INFORMATION));
//
// initialize the number of streams supported
//
StreamHeader->NumberOfStreams = 1;
StreamHeader->SizeOfHwStreamInformation = sizeof(HW_STREAM_INFORMATION);
//
// set the device property info
//
StreamHeader->NumDevPropArrayEntries = pDevExt->ulPropSetSupported;
StreamHeader->DevicePropertiesArray = &pDevExt->VideoProcAmpSet;
//
// Initialize the stream structure.
//
// Number of instances field indicates the number of concurrent streams
// of this type the device can support.
//
StreamInfo->NumberOfPossibleInstances = 1;
//
// indicates the direction of data flow for this stream, relative to
// the driver
//
StreamInfo->DataFlow = KSPIN_DATAFLOW_OUT;
//
// dataAccessible - Indicates whether the data is "seen" by the host
// processor.
//
StreamInfo->DataAccessible = TRUE;
//
// Return number of formats and the table.
// These information is collected dynamically.
//
StreamInfo->NumberOfFormatArrayEntries = pDevExt->ModeSupported;
StreamInfo->StreamFormatsArray = &pDevExt->DCamStrmModes[0];
//
// set the property information for the video stream
//
StreamInfo->NumStreamPropArrayEntries = NUMBER_VIDEO_STREAM_PROPERTIES;
StreamInfo->StreamPropertiesArray = (PKSPROPERTY_SET) VideoStreamProperties;
//
// set the pin name and category
//
StreamInfo->Name = (GUID *) &PINNAME_VIDEO_CAPTURE;
StreamInfo->Category = (GUID *) &PINNAME_VIDEO_CAPTURE;
//
// store a pointer to the topology for the device
//
Srb->CommandData.StreamBuffer->StreamHeader.Topology = &Topology;
//
// indicate success
//
Srb->Status = STATUS_SUCCESS;
DbgMsg2(("\'DCamGetStreamInfo: NumFormat %d, StreamFormatArray %x\n",
StreamInfo->NumberOfFormatArrayEntries, StreamInfo->StreamFormatsArray));
}
#define TIME_ROUNDING 1000 // Give it some rounding error of 100microsec
#define TIME_0750FPS (1333333+TIME_ROUNDING) // 1/7.50 * 10,000,000 (unit=100ns)
#define TIME_1500FPS (666666+TIME_ROUNDING) // 1/15.0 * 10,000,000 (unit=100ns) do not round to 666667
#define TIME_3000FPS (333333+TIME_ROUNDING) // 1/30.0 * 10,000,000 (unit=100ns)
NTSTATUS
DCamAllocateIsochResource(
PDCAM_EXTENSION pDevExt,
PIRB Irb,
BOOL bAllocateResource
)
{
PIRP Irp;
CCHAR StackSize;
ULONG ModeIndex;
PSTREAMEX pStrmEx;
DWORD dwAvgTimePerFrame, dwCompression;
ULONG fulSpeed;
NTSTATUS Status = STATUS_SUCCESS;
ASSERT(pDevExt);
pStrmEx = (PSTREAMEX) pDevExt->pStrmEx;
ASSERT(pStrmEx);
DbgMsg2(("\'DCamAllocateIsochResource: enter; pStrmEx %x; pVideoInfo %x\n", pStrmEx, pStrmEx->pVideoInfoHeader));
//
// Now if they're on a YUV4:2:2 format, we've gotta check what
// resolution they want it at, since we support this format
// but in two different resolutions (modes on the camera).
//
// This is the INDEX to the frame rate and resource allocation; see IsochInfoTable.
// 0 : reserved
// 1 : 3.75
// 2 : 7.5
// 3 : 15 (DEFAULT_FRAME_RATE)
// 4 : 30
// 5 : 60 (Not supported for Mode 1 & 3)
dwAvgTimePerFrame = (DWORD) pStrmEx->pVideoInfoHeader->AvgTimePerFrame;
dwCompression = (DWORD) pStrmEx->pVideoInfoHeader->bmiHeader.biCompression;
// Determine the Frame rate
if (dwAvgTimePerFrame > TIME_0750FPS)
pDevExt->FrameRate = 1; // 3.75FPS
else if (dwAvgTimePerFrame > TIME_1500FPS)
pDevExt->FrameRate = 2; // 7.5FPS
else if (dwAvgTimePerFrame > TIME_3000FPS)
pDevExt->FrameRate = 3; // 15 FPS
else
pDevExt->FrameRate = 4; // 30 FPS
DbgMsg2(("\'DCamAllocateIsochResource: FrameRate: %d FPS\n", (1 << (pDevExt->FrameRate-1)) * 15 / 4));
// Determine the Video Mode
switch(dwCompression) {
#ifdef SUPPORT_YUV444
case FOURCC_Y444: // Mode 0
ModeIndex = VMODE0_YUV444;
break;
#endif
case FOURCC_UYVY: // Mode 1 or 3
if (pStrmEx->pVideoInfoHeader->bmiHeader.biWidth == 640 &&
(pStrmEx->pVideoInfoHeader->bmiHeader.biHeight == 480 ||
pStrmEx->pVideoInfoHeader->bmiHeader.biHeight == -480)) {
ModeIndex = VMODE3_YUV422;
// Max frame rate is 15
if(pDevExt->FrameRate > 3)
pDevExt->FrameRate = 3;
} else
ModeIndex = VMODE1_YUV422;
break;
#ifdef SUPPORT_YUV411
case FOURCC_Y411: // Mode 2
ModeIndex = VMODE2_YUV411;
break;
#endif
#ifdef SUPPORT_RGB24
case KS_BI_RGB: // = 0
ModeIndex = VMODE4_RGB24;
// Max frame rate is 15
if(pDevExt->FrameRate > 3)
pDevExt->FrameRate = 3;
break;
#endif
#ifdef SUPPORT_YUV800
case FOURCC_Y800:
ModeIndex = VMODE5_YUV800;
break;
#endif
default:
Status = STATUS_NOT_IMPLEMENTED;;
return Status;;
}
DbgMsg1(("\'DCamAllocateIsochResource: ModeIndex=%d, AvgTimePerFrame=%d, FrameRate=%d\n",
ModeIndex, dwAvgTimePerFrame, pDevExt->FrameRate));
//
// Get an Irp so we can send some allocation commands down
//
StackSize = pDevExt->BusDeviceObject->StackSize;
Irp = IoAllocateIrp(StackSize, FALSE);
if (!Irp) {
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Calculate the index to use to reference the ISOCH table
//
pStrmEx->idxIsochTable = ModeIndex * NUM_POSSIBLE_RATES + pDevExt->FrameRate;
ASSERT(pStrmEx->pVideoInfoHeader->bmiHeader.biSizeImage == IsochInfoTable[pStrmEx->idxIsochTable].CompletePictureSize);
DbgMsg2(("\'DCamAllocateIsochResource: ModeIndex=%d, idxIsochTable=%d, biSizeImage=%d, CompletePictureSize=%d\n",
ModeIndex, pStrmEx->idxIsochTable, pStrmEx->pVideoInfoHeader->bmiHeader.biSizeImage, IsochInfoTable[pStrmEx->idxIsochTable].CompletePictureSize));
//
// 0. Determine the MAX_SPEED and not use the speed defined in the static table.
//
Irb->FunctionNumber = REQUEST_GET_SPEED_BETWEEN_DEVICES;
Irb->Flags = 0;
Irb->u.GetMaxSpeedBetweenDevices.fulFlags = USE_LOCAL_NODE;
Irb->u.GetMaxSpeedBetweenDevices.ulNumberOfDestinations = 0;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
if(Status) {
ERROR_LOG(("\'DCamAllocateIsochResource: Error %x while trying to get maximun speed between devices.\n", Status));
IoFreeIrp(Irp);
return STATUS_INSUFFICIENT_RESOURCES;
}
fulSpeed = Irb->u.GetMaxSpeedBetweenDevices.fulSpeed;
//
// The max speed between devices should be within supported speed range, and
// must be equal or greater than the required speed for the chosen format.
//
if(
( fulSpeed != SPEED_FLAGS_100
&& fulSpeed != SPEED_FLAGS_200
&& fulSpeed != SPEED_FLAGS_400
)
|| fulSpeed < IsochInfoTable[pStrmEx->idxIsochTable].SpeedRequired
) {
ASSERT(fulSpeed == SPEED_FLAGS_100 || fulSpeed == SPEED_FLAGS_200 || fulSpeed == SPEED_FLAGS_400);
ASSERT(fulSpeed >= IsochInfoTable[pStrmEx->idxIsochTable].SpeedRequired);
IoFreeIrp(Irp);
return STATUS_UNSUCCESSFUL;
}
pDevExt->SpeedCode = fulSpeed >> 1; // Safe for S100, 200 and 400 (is checked above).
DbgMsg2(("\'GetMaxSpeedBetweenDevices.fulSpeed=%x; SpeedCode:%x\n", fulSpeed, pDevExt->SpeedCode));
//
// 1. Allocate CHANNEL
// First try to re-allocate the same channel
// If it is used, try to get any channel. 1394DCam can only be on channel 0..15
//
Irb->FunctionNumber = REQUEST_ISOCH_ALLOCATE_CHANNEL;
Irb->Flags = 0;
//
// ULONG nRequestedChannel; // Need a specific channel
// ULONG Channel; // Returned channel
// LARGE_INTEGER ChannelsAvailable; // Channels available
// Instead of hardcoded '0'; use -1 to ask the bus driver to get the next available channel for us.
// -1 (any channel) or an existing channel
Irb->u.IsochAllocateChannel.nRequestedChannel = pDevExt->IsochChannel;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
if(Status) {
//
// Due to channel change,
// all Pending read will be either resubmitted,
// or cancelled (if out of resource).
//
pDevExt->bStopIsochCallback = TRUE; // Set back to FALSE after pending buffer are attached.
//
// If this is an initial request and no channel available,
// free all resource and abort.
//
if(pDevExt->IsochChannel == ISOCH_ANY_CHANNEL)
goto NoResource_abort;
DbgMsg1(("DCamAllocateIsochResource: last allocated channel %d is not available; pending count %d.\n",
pDevExt->IsochChannel, pDevExt->PendingReadCount));
// Try gettting any channel.
Irb->FunctionNumber = REQUEST_ISOCH_ALLOCATE_CHANNEL;
Irb->Flags = 0;
Irb->u.IsochAllocateChannel.nRequestedChannel = ISOCH_ANY_CHANNEL;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
if(Status) {
ERROR_LOG(("DCamAllocateIsochResource: allocate any channel failed, status %x!\n", Status));
goto NoResource_abort;
}
//
// Channel changed, we MUST reallocate resource.
// The "stale" resrouce will be free later when
// pending packet are detached.
//
bAllocateResource = TRUE;
}
DbgMsg1(("**IsochAlloc: Channel(Old) %d, requested %d, got %d, HiLo(0x%x:%x), PendingRead %d\n",
pDevExt->IsochChannel,
Irb->u.IsochAllocateChannel.nRequestedChannel,
Irb->u.IsochAllocateChannel.Channel,
Irb->u.IsochAllocateChannel.ChannelsAvailable.u.HighPart,
Irb->u.IsochAllocateChannel.ChannelsAvailable.u.LowPart,
pDevExt->PendingReadCount));
// New channel
pDevExt->IsochChannel = Irb->u.IsochAllocateChannel.Channel; // Used in allocating iso. resource and reallocation
//
// 2. Allocate BANDWIDTH
//
Irb->FunctionNumber = REQUEST_ISOCH_ALLOCATE_BANDWIDTH;
Irb->Flags = 0;
Irb->u.IsochAllocateBandwidth.nMaxBytesPerFrameRequested = IsochInfoTable[pStrmEx->idxIsochTable].QuadletPayloadPerPacket << 2;
Irb->u.IsochAllocateBandwidth.fulSpeed = fulSpeed;
Irb->u.IsochAllocateBandwidth.hBandwidth = 0;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
if(Status) {
ERROR_LOG(("DCamAllocateIsochResource: Error %x while trying to allocate Isoch bandwidth\n", Status));
goto NoResource_abort;
}
pDevExt->hBandwidth = Irb->u.IsochAllocateBandwidth.hBandwidth;
DbgMsg2(("**IsochAlloc: nMaxBytesPerFrameRequested %d, fulSpeed %d; hBandWidth 0x%x\n",
IsochInfoTable[pStrmEx->idxIsochTable].QuadletPayloadPerPacket << 2, fulSpeed, pDevExt->hBandwidth));
//
// 3. Allocate RESOURCES
// Note: after a bus reset, we need not free and re-allocate this resoruce again.
//
if(bAllocateResource) {
Irb->FunctionNumber = REQUEST_ISOCH_ALLOCATE_RESOURCES;
Irb->Flags = 0;
Irb->u.IsochAllocateResources.fulSpeed = fulSpeed;
Irb->u.IsochAllocateResources.nChannel = pDevExt->IsochChannel;
Irb->u.IsochAllocateResources.nMaxBytesPerFrame = IsochInfoTable[pStrmEx->idxIsochTable].QuadletPayloadPerPacket << 2;
// For slower frame rate use smaller quadlets
// smaller frame size will use more packet to fill the same amount of data
// this is why smaller frame rate actually demand more resource !!
Irb->u.IsochAllocateResources.nNumberOfBuffers = MAX_BUFFERS_SUPPLIED + 1; // "+1" as a "safety"
Irb->u.IsochAllocateResources.nMaxBufferSize = IsochInfoTable[pStrmEx->idxIsochTable].CompletePictureSize;
if (pDevExt->HostControllerInfomation.HostCapabilities & HOST_INFO_SUPPORTS_RETURNING_ISO_HDR) {
Irb->u.IsochAllocateResources.nQuadletsToStrip = 1;
Irb->u.IsochAllocateResources.fulFlags = RESOURCE_USED_IN_LISTENING | RESOURCE_STRIP_ADDITIONAL_QUADLETS;
} else {
Irb->u.IsochAllocateResources.nQuadletsToStrip = 0;
Irb->u.IsochAllocateResources.fulFlags = RESOURCE_USED_IN_LISTENING;
}
Irb->u.IsochAllocateResources.hResource = 0;
DbgMsg2(("\'DCamAllocateIsochResource: fullSpeed(%d), nMaxBytesPerFrame(%d), nMaxBufferSize(%d)\n",
Irb->u.IsochAllocateResources.fulSpeed,
Irb->u.IsochAllocateResources.nMaxBytesPerFrame,
Irb->u.IsochAllocateResources.nMaxBufferSize));
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
if(Status) {
ERROR_LOG(("DCamAllocateIsochResource: Error %x while trying to allocate Isoch resources\n", Status));
goto NoResource_abort;
}
pDevExt->hResource = Irb->u.IsochAllocateResources.hResource;
}
pDevExt->CurrentModeIndex = ModeIndex;
DbgMsg2(("**IsochAlloc: hResource = %x\n", pDevExt->hResource));
IoFreeIrp(Irp);
return STATUS_SUCCESS;
NoResource_abort:
// Free bandwidth
if(pDevExt->hBandwidth != NULL) {
Irb->FunctionNumber = REQUEST_ISOCH_FREE_BANDWIDTH;
Irb->Flags = 0;
Irb->u.IsochFreeBandwidth.hBandwidth = pDevExt->hBandwidth;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
pDevExt->hBandwidth = NULL;
if(Status) {
ERROR_LOG(("DCamAllocateIsochResource: Error %x while trying to free Isoch bandwidth\n", Status));
}
}
// Free channel
if (pDevExt->IsochChannel != ISOCH_ANY_CHANNEL) {
Irb->FunctionNumber = REQUEST_ISOCH_FREE_CHANNEL;
Irb->Flags = 0;
Irb->u.IsochFreeChannel.nChannel = pDevExt->IsochChannel;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
pDevExt->IsochChannel = ISOCH_ANY_CHANNEL; // Reset it.
if(Status) {
ERROR_LOG(("DCamAllocateIsochResource: Error %x while trying to free Isoch channel\n", Status));
}
}
IoFreeIrp(Irp);
return STATUS_INSUFFICIENT_RESOURCES;
}
NTSTATUS
DCamFreeIsochResource (
PDCAM_EXTENSION pDevExt,
PIRB Irb,
BOOL bFreeResource
)
/*++
Routine Description:
Free resource allocated in DCamAllocateIsochResource().
Arguments:
Srb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
PIRP Irp;
CCHAR StackSize;
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DbgMsg2(("\'DCamFreeIsochResource: enter; DevExt=%x, Irb=%x\n", pDevExt, Irb));
ASSERT(pDevExt);
ASSERT(Irb);
if(Irb == 0 ||
pDevExt == 0) {
DbgMsg2(("\'DCamFreeIsochResource: ABORTED!\n"));
return STATUS_SUCCESS;
}
//
// Get an Irp so we can send some free commands down
//
StackSize = pDevExt->BusDeviceObject->StackSize;
Irp = IoAllocateIrp(StackSize, FALSE);
if (!Irp) {
ERROR_LOG(("DCamFreeIsochResource: Error %x while trying to allocate an Irp\n\n", Status));
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// 1. Free Resource
//
if (pDevExt->hResource && bFreeResource) {
DbgMsg2(("\'DCamFreeIsochResource: Attempt to free ->hResource\n"));
Irb->FunctionNumber = REQUEST_ISOCH_FREE_RESOURCES;
Irb->Flags = 0;
Irb->u.IsochFreeResources.hResource = pDevExt->hResource;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
pDevExt->hResource = NULL;
if (Status) {
ERROR_LOG(("DCamFreeIsochResource: Error %x while trying to free Isoch resources\n\n", Status));
}
}
//
// 2. Free Channel
//
if (pDevExt->IsochChannel != ISOCH_ANY_CHANNEL) {
DbgMsg2(("\'DCamFreeIsochResource: Attempt to free ->IsochChannel\n"));
Irb->FunctionNumber = REQUEST_ISOCH_FREE_CHANNEL;
Irb->Flags = 0;
Irb->u.IsochFreeChannel.nChannel = pDevExt->IsochChannel;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
pDevExt->IsochChannel = ISOCH_ANY_CHANNEL;
if(Status) {
ERROR_LOG(("DCamFreeIsochResource: Error %x while trying to free Isoch channel\n\n", Status));
}
}
//
// 3. Free Bandwidth
//
if (pDevExt->hBandwidth) {
DbgMsg2(("\'DCamFreeIsochResource: Attempt to free ->hBandwidth\n"));
Irb->FunctionNumber = REQUEST_ISOCH_FREE_BANDWIDTH;
Irb->Flags = 0;
Irb->u.IsochFreeBandwidth.hBandwidth = pDevExt->hBandwidth;
Status = DCamSubmitIrpSynch(pDevExt, Irp, Irb);
pDevExt->hBandwidth = NULL;
if (Status) {
ERROR_LOG(("DCamFreeIsochResource: Error %x while trying to free Isoch bandwidth\n", Status));
}
}
DbgMsg2(("\'DCamFreeIsochResource: hResource = %x\n", pDevExt->hResource));
IoFreeIrp(Irp);
return STATUS_SUCCESS;
}
VOID
InitializeStreamExtension(
PDCAM_EXTENSION pDevExt,
PHW_STREAM_OBJECT pStreamObject,
PSTREAMEX pStrmEx
)
{
PAGED_CODE();
pStrmEx->hMasterClock = 0;
pStrmEx->FrameInfo.ExtendedHeaderSize = sizeof(KS_FRAME_INFO);
pStrmEx->FrameInfo.PictureNumber = 0;
pStrmEx->FrameInfo.DropCount = 0;
pStrmEx->FrameInfo.dwFrameFlags = 0;
pStrmEx->FirstFrameTime = 0;
pStrmEx->pVideoInfoHeader = 0;
pStrmEx->KSState = KSSTATE_STOP;
pStrmEx->KSSavedState = KSSTATE_STOP;
KeInitializeMutex( &pStrmEx->hMutex, 0); // Level 0 and in Signal state
}
BOOL
DCamDeviceInUse(
PIRB pIrb,
PDCAM_EXTENSION pDevExt
)
/*++
Routine Description:
See if this device is in used.
We check ISO_ENABLE since this is the only register
in a 1394DCam that we can set/get and 99%+ of time
this bit is set by its owner.
Arguments:
pIrb - Pointer to IEEE 1394 Request Block definition (IRB)
pDevExt - this device extension
Return Value:
TRUE: Iso_enable != 0
FALSE: iso_enable == 0
--*/
{
DCamRegArea RegArea;
NTSTATUS status;
LONG lRetries = MAX_READ_REG_RETRIES;
// If a device is removed, it is not available.
if(pDevExt->bDevRemoved)
return TRUE;
do {
RegArea.AsULONG = 0;
status = DCamReadRegister(pIrb, pDevExt, FIELDOFFSET(CAMERA_REGISTER_MAP, IsoEnable), &(RegArea.AsULONG));
#if DBG
if(!NT_SUCCESS(status))
ERROR_LOG(("**** DCamDeviceInUse: Status %x, ISO_ENABLE %x\n", status, RegArea.AsULONG));
#endif
} while (--lRetries > 0 && !NT_SUCCESS(status));
if(NT_SUCCESS(status))
return ((RegArea.AsULONG & ISO_ENABLE_BIT) == ISO_ENABLE_BIT);
// failed to query the device.
return TRUE; // Assume it is in use.
}
VOID
DCamOpenStream(
IN PHW_STREAM_REQUEST_BLOCK pSrb
)
/*++
Routine Description:
Called when an OpenStream Srb request is received
Arguments:
pSrb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
PIRB Irb;
ULONG nSize;
PDCAM_EXTENSION pDevExt;
PSTREAMEX pStrmEx;
PKS_DATAFORMAT_VIDEOINFOHEADER pKSDataFormat =
(PKS_DATAFORMAT_VIDEOINFOHEADER) pSrb->CommandData.OpenFormat;
PKS_VIDEOINFOHEADER pVideoInfoHdrRequested =
&pKSDataFormat->VideoInfoHeader;
PAGED_CODE();
Irb = (PIRB) pSrb->SRBExtension;
pDevExt = (PDCAM_EXTENSION) pSrb->HwDeviceExtension;
pStrmEx = (PSTREAMEX)pSrb->StreamObject->HwStreamExtension;
DbgMsg2(("\'DCamOpenStream: >>> !!! pDevEx %x; pStrmEx %x !!!\n", pDevExt, pStrmEx));
//
// Cache the stream extension.
//
pDevExt->pStrmEx = pStrmEx;
//
// default to success
//
pSrb->Status = STATUS_SUCCESS;
//
// determine which stream number is being opened. This number indicates
// the offset into the array of streaminfo structures that was filled out
// in the AdapterStreamInfo call.
//
// So:
// 0 - Video data from camera
//
switch (pSrb->StreamObject->StreamNumber) {
case 0:
//
// Make sure that this device is not in used
//
if(DCamDeviceInUse(Irb, pDevExt)) {
ERROR_LOG(("Device is in used! Open Stream fail!!\n"));
pDevExt->pStrmEx = NULL;
pSrb->Status = STATUS_UNSUCCESSFUL;
return;
}
//
// Figure out what format they're trying to open first
//
if (!AdapterVerifyFormat (pDevExt->ModeSupported, pDevExt->DCamStrmModes, pKSDataFormat, pSrb->StreamObject->StreamNumber)) {
pDevExt->pStrmEx = NULL;
ERROR_LOG(("DCamOpenStream: AdapterVerifyFormat failed.\n"));
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
InitializeStreamExtension(pDevExt, pSrb->StreamObject, pStrmEx);
// It should already been freed by DCamCloseStream()
ASSERT(pStrmEx->pVideoInfoHeader == NULL);
ASSERT(pVideoInfoHdrRequested != (PKS_VIDEOINFOHEADER) 0);
// Use this instead of sizeof(KS_VIDEOINFOHEADER) to handle variable size structure
nSize = KS_SIZE_VIDEOHEADER (pVideoInfoHdrRequested);
pStrmEx->pVideoInfoHeader = ExAllocatePoolWithTag(NonPagedPool, nSize, 'macd');
if (pStrmEx->pVideoInfoHeader == NULL) {
ERROR_LOG(("DCamOpenStream: ExAllocatePool (->pVideoInfoHeader) failed!\n"));
ASSERT(pStrmEx->pVideoInfoHeader != NULL);
pDevExt->pStrmEx = NULL;
pSrb->Status = STATUS_INSUFFICIENT_RESOURCES;
return;
}
// Copy the VIDEOINFOHEADER requested to our storage
RtlCopyMemory(
pStrmEx->pVideoInfoHeader,
pVideoInfoHdrRequested,
nSize);
DbgMsg3(("\'DCamOpenStream: Copied biSizeImage=%d Duration=%ld (100ns)\n",
pStrmEx->pVideoInfoHeader->bmiHeader.biSizeImage, (DWORD) pStrmEx->pVideoInfoHeader->AvgTimePerFrame));
// Allocate ISOCH resource
pSrb->Status = DCamAllocateIsochResource(pDevExt, pSrb->SRBExtension, TRUE);
if (pSrb->Status) {
ERROR_LOG(("DCamOpenStream: !!!! Allocate ISOCH resource failed. CanNOT STREAM!!!!!\n"));
ExFreePool(pStrmEx->pVideoInfoHeader);
pStrmEx->pVideoInfoHeader = NULL;
pDevExt->pStrmEx = NULL;
pSrb->Status = STATUS_INSUFFICIENT_RESOURCES;
return;
}
pSrb->StreamObject->ReceiveDataPacket = (PVOID) DCamReceiveDataPacket;
pSrb->StreamObject->ReceiveControlPacket = (PVOID) DCamReceiveCtrlPacket;
// If bus reset failed and user close the stream and reopen the stream successfully,
// This must be reset !!
if(pDevExt->bDevRemoved || pDevExt->bStopIsochCallback) {
DbgMsg1(("Stream Open successful, reset bDevRemoved and bStopCallback!!\n"));
pDevExt->bStopIsochCallback = FALSE;
pDevExt->bDevRemoved = FALSE;
}
//
// initialize the stream extension data handling information
//
break;
default:
ERROR_LOG(("DCamOpenStream: Hit a non-support pSrb->StreamObject->StreamNumber (%d).\n", pSrb->StreamObject->StreamNumber));
ASSERT(FALSE);
pDevExt->pStrmEx = NULL;
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
pSrb->StreamObject->HwClockObject.ClockSupportFlags = 0;
// We don't use DMA.
pSrb->StreamObject->Dma = FALSE;
pSrb->StreamObject->StreamHeaderMediaSpecific = sizeof(KS_FRAME_INFO);
//
// The PIO flag must be set when the mini driver will be accessing the data
// buffers passed in using logical addressing. We are not going to touch these
// buffer at all.
//
pSrb->StreamObject->Pio = FALSE;
//
// Set to last saved configuration
//
SetCurrentDevicePropertyValues(pDevExt, (PIRB) pSrb->SRBExtension);
DbgMsg1((" #OPEN_STREAM#: %s DCam, Status %x, pDevExt %x, pStrmEx %x, IsochDescriptorList is at %x\n",
pDevExt->pchVendorName, pSrb->Status, pDevExt, pDevExt->pStrmEx, &pDevExt->IsochDescriptorList));
ASSERT(pSrb->Status == STATUS_SUCCESS);
}
VOID
DCamCloseStream(
IN PHW_STREAM_REQUEST_BLOCK pSrb
)
/*++
Routine Description:
Called when an CloseStream Srb request is received. We get this when calling user
application do a CloseHandle() on the pin connection handle. This can happen after
HwUninitialize().
Arguments:
pSrb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
PDCAM_EXTENSION pDevExt;
PSTREAMEX pStrmEx;
PIRB pIrb;
PAGED_CODE();
pSrb->Status = STATUS_SUCCESS;
pDevExt = (PDCAM_EXTENSION) pSrb->HwDeviceExtension;
ASSERT(pDevExt);
if(!pDevExt) {
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
return;
}
pStrmEx = (PSTREAMEX)pDevExt->pStrmEx;
ASSERT(pStrmEx);
if(!pStrmEx ) {
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
return;
}
//
// pDevExt->Irb might have been freed in HwUninitialize()
// due to Surprise removal; so we must use this:
//
pIrb = (PIRB) pSrb->SRBExtension;
//
// If it is still in use (setting it to stop failed?),
// we will diable ISO_ENABLE so other application can use it.
//
if(!pDevExt->bDevRemoved &&
DCamDeviceInUse(pIrb, pDevExt)) {
DbgMsg1(("DCamCloseStream: Is still in use! Disable it!\n"));
// Disable EnableISO
DCamIsoEnable(pIrb, pDevExt, FALSE);
}
//
// Save current state and free resource alllocaed in OpenStream()
//
DCamSetPropertyValuesToRegistry(pDevExt);
//
// Free Isoch resource and master clock
//
DCamFreeIsochResource (pDevExt, pIrb, TRUE);
if(pStrmEx->pVideoInfoHeader) {
ExFreePool(pStrmEx->pVideoInfoHeader);
pStrmEx->pVideoInfoHeader = NULL;
}
pStrmEx->hMasterClock = 0;
//
// If there are pening read, cancel them all.
//
if(pDevExt->PendingReadCount > 0) {
DCamCancelAllPackets(
pSrb,
pDevExt,
&pDevExt->PendingReadCount
);
pDevExt->pStrmEx = 0;
return; // SRB completed in CancelAllPackets
}
pDevExt->pStrmEx = 0;
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
}
VOID
DCamTimeoutHandler(
IN PHW_STREAM_REQUEST_BLOCK pSrb
)
/*++
Routine Description:
This routine is called when a packet has been in the minidriver too long (Srb->TimeoutCounter == 0).
We will cancel the SRB if we are in the RUN state; else set ->TimeoutCounter and return.
We assume the cancel SRB is serialized and in the same order as it is read. So this timeout is
applying to the head of the queue.
Arguments:
pSrb - Pointer to Stream request block that has timeout.
Return Value:
Nothing
--*/
{
PDCAM_EXTENSION pDevExt;
PSTREAMEX pStrmEx;
// Called from StreamClass at DisptchLevel
//
// We only expect stream SRB, but not device SRB.
//
if ( (pSrb->Flags & SRB_HW_FLAGS_STREAM_REQUEST) != SRB_HW_FLAGS_STREAM_REQUEST) {
ERROR_LOG(("DCamTimeoutHandler: Device SRB %x (cmd:%x) timed out!\n", pSrb, pSrb->Command));
return;
}
//
// StreamSRB only valid if we have a stream extension
//
pDevExt = (PDCAM_EXTENSION) pSrb->HwDeviceExtension;
ASSERT(pDevExt);
pStrmEx = (PSTREAMEX) pDevExt->pStrmEx;
if(!pStrmEx) {
ERROR_LOG(("DCamTimeoutHandler: Stream SRB %x timeout with pDevExt %x, pStrmEx %x\n", pSrb, pDevExt, pStrmEx));
ASSERT(pStrmEx);
return;
}
//
// Cancel IRP only if in RUN state, BUT...
// Note: if we are TIMEOUT and in RUN state, something is terribley wrong.
// but I guess that can happen when it is being suspended;
// so we will extend the time out for all states.
//
DbgMsg2(("\'DCamTimeoutHandler: pSrb %x, %s state, PendingReadCount %d.\n",
pSrb,
pStrmEx->KSState == KSSTATE_RUN ? "RUN" :
pStrmEx->KSState == KSSTATE_PAUSE ? "PAUSE":
pStrmEx->KSState == KSSTATE_STOP ? "STOP": "Unknown",
pDevExt->PendingReadCount));
// ASSERT(pStrmEx->KSState == KSSTATE_PAUSE);
//
// Reset Timeout counter, or we are going to get this call immediately.
//
pSrb->TimeoutCounter = pSrb->TimeoutOriginal;
}
NTSTATUS
DCamStartListenCR(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP pIrp,
IN PDCAM_IO_CONTEXT pDCamIoContext
)
/*++
Routine Description:
Returns more processing required so the IO Manager will leave us alone
Arguments:
DriverObject - Pointer to driver object created by system.
pIrp - Irp that just completed
pDCamIoContext - Context
Return Value:
None.
--*/
{
PDCAM_EXTENSION pDevExt;
NTSTATUS Status;
PIRB pIrb;
PIO_STACK_LOCATION NextIrpStack;
#ifdef WAIT_FOR_SLOW_DEVICE
KeStallExecutionProcessor(5000); // 5 msec
#endif
DbgMsg2(("\'DCamStartListenCR: pIrp->IoStatus.Status=%x\n", pIrp->IoStatus.Status));
if(STATUS_SUCCESS != pIrp->IoStatus.Status) {
pDevExt = pDCamIoContext->pDevExt;
pIrb = pDCamIoContext->pIrb;
if(pDevExt->lRetries > 0) {
pDevExt->lRetries--;
DbgMsg1(("DCamStartListenCR: Try DCAM_RUNSTATE_SET_REQUEST_ISOCH_LISTEN again!\n"));
pIrb->FunctionNumber = REQUEST_ISOCH_LISTEN;
pIrb->Flags = 0;
pIrb->u.IsochListen.hResource = pDevExt->hResource;
pIrb->u.IsochListen.fulFlags = 0;
NextIrpStack = IoGetNextIrpStackLocation(pIrp);
NextIrpStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
NextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_1394_CLASS;
NextIrpStack->Parameters.Others.Argument1 = pIrb;
IoSetCompletionRoutine(
pIrp,
DCamStartListenCR,
pDCamIoContext,
TRUE,
TRUE,
TRUE
);
Status =
IoCallDriver(
pDevExt->BusDeviceObject,
pIrp);
return STATUS_MORE_PROCESSING_REQUIRED;
} else {
ERROR_LOG(("Start Listening has failed Status=%x; try again in next read.\n", pIrp->IoStatus.Status));
pDCamIoContext->pDevExt->bNeedToListen = TRUE;
}
}
DCamFreeIrbIrpAndContext(pDCamIoContext, pDCamIoContext->pIrb, pIrp);
// No StreamClassDeviceNotification() here since
// this is local initiated Irb (as part of AttachBufferCR().
return STATUS_MORE_PROCESSING_REQUIRED;
}
/*
** AdapterCompareGUIDsAndFormatSize()
**
** Checks for a match on the three GUIDs and FormatSize
**
** Arguments:
**
** IN DataRange1
** IN DataRange2
**
** Returns:
**
** TRUE if all elements match
** FALSE if any are different
**
** Side Effects: none
*/
BOOL
AdapterCompareGUIDsAndFormatSize(
IN PKSDATARANGE DataRange1,
IN PKSDATARANGE DataRange2)
{
PAGED_CODE();
return (
IsEqualGUID (
&DataRange1->MajorFormat,
&DataRange2->MajorFormat) &&
IsEqualGUID (
&DataRange1->SubFormat,
&DataRange2->SubFormat) &&
IsEqualGUID (
&DataRange1->Specifier,
&DataRange2->Specifier) &&
(DataRange1->FormatSize == DataRange2->FormatSize));
}
/*
** AdapterVerifyFormat()
**
** Checks the validity of a format request by walking through the
** array of supported PKSDATARANGEs for a given stream.
**
** Arguments:
**
** pKSDataFormatVideoToVerify - pointer of a KS_DATAFORMAT_VIDEOINFOHEADER structure.
** StreamNumber - index of the stream being queried / opened.
**
** Returns:
**
** TRUE if the format is supported
** FALSE if the format cannot be suppored
**
** Side Effects: none
*/
BOOL
AdapterVerifyFormat(
ULONG VideoModesSupported,
PKSDATAFORMAT *pDCamStrmModesSupported,
PKS_DATAFORMAT_VIDEOINFOHEADER pDataFormatVideoToVerify,
int StreamNumber)
{
PKS_VIDEOINFOHEADER pVideoInfoHdrToVerify = &pDataFormatVideoToVerify->VideoInfoHeader;
PKSDATAFORMAT *paDataFormatsVideoAvail; // an array of PKSDATAFORMAT (not PKS_DATARANGE_VIDEO !!)
PKS_DATARANGE_VIDEO pDataRangeVideo;
KS_VIDEO_STREAM_CONFIG_CAPS *pConfigCaps;
PKS_BITMAPINFOHEADER pbmiHeader,
pbmiHeaderToVerify;
int j;
PAGED_CODE();
//
// Make sure the stream index is valid
// We only has one capure pin/stream (index 0).
//
if (StreamNumber >= 1) {
return FALSE;
}
//
// Get the pointer to the array of available formats
//
paDataFormatsVideoAvail = &pDCamStrmModesSupported[0]; // &pDevExt->DCamStrmModes[0];
//
// Walk the array, searching for a match
//
for (j = 0; j < (LONG) VideoModesSupported; j++, paDataFormatsVideoAvail++) {
pDataRangeVideo = (PKS_DATARANGE_VIDEO) *paDataFormatsVideoAvail;
//
// Check for matching size, Major Type, Sub Type, and Specifier
//
//
// Check for matching size, Major Type, Sub Type, and Specifier
//
if (!IsEqualGUID (&pDataRangeVideo->DataRange.MajorFormat,
&pDataFormatVideoToVerify->DataFormat.MajorFormat)) {
DbgMsg2(("\'%d) AdapterVerifyFormat: MajorFormat mismatch!\n", j));
continue;
}
if (!IsEqualGUID (&pDataRangeVideo->DataRange.SubFormat,
&pDataFormatVideoToVerify->DataFormat.SubFormat)) {
DbgMsg2(("\'%d) AdapterVerifyFormat: SubFormat mismatch!\n", j));
continue;
}
if (!IsEqualGUID (&pDataRangeVideo->DataRange.Specifier,
&pDataFormatVideoToVerify->DataFormat.Specifier)) {
DbgMsg2(("\'%d) AdapterVerifyFormat: Specifier mismatch!\n", j));
continue;
}
if(pDataFormatVideoToVerify->DataFormat.FormatSize <
sizeof(KS_DATAFORMAT_VIDEOINFOHEADER))
continue;
//
// Only if we get here, we are certain that we are dealing with video info.
//
// We do not support scaling or cropping so the dimension
// (biWidth, biHeight, biBitCount and biCompression)
// must match.
//
pbmiHeader = &pDataRangeVideo->VideoInfoHeader.bmiHeader;
pbmiHeaderToVerify = &pDataFormatVideoToVerify->VideoInfoHeader.bmiHeader;
if(pbmiHeader->biWidth != pbmiHeaderToVerify->biWidth ||
pbmiHeader->biHeight != pbmiHeaderToVerify->biHeight ||
pbmiHeader->biBitCount != pbmiHeaderToVerify->biBitCount ||
pbmiHeader->biCompression != pbmiHeaderToVerify->biCompression
) {
DbgMsg2(("AdapterVerifyFormat: Supported: %dx%dx%d [%x] != ToVerify: %dx%dx%d [%x]\n",
pbmiHeader->biWidth, pbmiHeader->biHeight, pbmiHeader->biBitCount, pbmiHeader->biCompression,
pbmiHeaderToVerify->biWidth, pbmiHeaderToVerify->biHeight, pbmiHeaderToVerify->biBitCount, pbmiHeaderToVerify->biCompression));
continue;
}
// biSizeImage must be to be BIG ENOUGH
if(pbmiHeaderToVerify->biSizeImage < pbmiHeader->biSizeImage) {
DbgMsg2(("AdapterVerifyFormat: biSizeImageToVerify %d < required %x\n",
pbmiHeaderToVerify->biSizeImage, pbmiHeader->biSizeImage));
continue;
}
// Frame rate needs to be within range
pConfigCaps = &pDataRangeVideo->ConfigCaps;
if(pDataFormatVideoToVerify->VideoInfoHeader.AvgTimePerFrame > pConfigCaps->MaxFrameInterval &&
pDataFormatVideoToVerify->VideoInfoHeader.AvgTimePerFrame < pConfigCaps->MinFrameInterval) {
DbgMsg2(("\'format index %d) AdapterVerifyFormat: Frame rate %ld is not within range(%ld, %ld)!\n",
j, pDataFormatVideoToVerify->VideoInfoHeader.AvgTimePerFrame,
pConfigCaps->MaxFrameInterval, pConfigCaps->MinFrameInterval));
continue;
}
//
// The format passed all of the tests, so we support it
//
DbgMsg2(("\'(format idx %d) AdapterVerifyFormat: Verify!! Width=%d, Height=%d, biBitCount=%d, biSizeImage=%d\n", j,
pbmiHeaderToVerify->biWidth, pbmiHeaderToVerify->biHeight, pbmiHeaderToVerify->biBitCount,pbmiHeaderToVerify->biSizeImage));
DbgMsg2(("AdapterVerifyFormat: AvgTimePerFrame = %ld\n", pDataFormatVideoToVerify->VideoInfoHeader.AvgTimePerFrame));
DbgMsg2(("AdapterVerifyFormat: (Max %ld\n", pConfigCaps->MaxFrameInterval));
DbgMsg2(("AdapterVerifyFormat: Min %ld)\n", pConfigCaps->MinFrameInterval));
return TRUE;
}
//
// The format requested didn't match any of our listed ranges,
// so refuse the connection.
//
DbgMsg2(("AdapterVerifyFormat: This format is not supported!\n"));
return FALSE;
}
/*
** AdapterFormatFromRange()
**
** Examine the given data format with many key fields and
** return a complete data format that can be used to open a stream.
**
** Arguments:
**
** IN PHW_STREAM_REQUEST_BLOCK Srb
**
** Returns:
**
** TRUE if the format is supported
** FALSE if the format cannot be suppored
**
** Side Effects: none
*/
BOOL
AdapterFormatFromRange(
IN PHW_STREAM_REQUEST_BLOCK Srb)
{
PDCAM_EXTENSION pDevExt = (PDCAM_EXTENSION) Srb->HwDeviceExtension;
PSTREAM_DATA_INTERSECT_INFO IntersectInfo;
PKSDATARANGE DataRange,
*pAvailableFormats; // KSDATARANGE == KSDATAFORMAT
PKS_DATARANGE_VIDEO DataRangeVideoToVerify,
DataRangeVideo;
PKS_BITMAPINFOHEADER pbmiHeader,
pbmiHeaderToVerify;
ULONG FormatSize;
BOOL MatchFound = FALSE;
ULONG j;
PAGED_CODE();
Srb->Status = STATUS_SUCCESS;
IntersectInfo = Srb->CommandData.IntersectInfo;
DataRange = IntersectInfo->DataRange;
DbgMsg2(("IntersectIfo->DataFormatBuffer=%x, size=%d\n", IntersectInfo->DataFormatBuffer, IntersectInfo->SizeOfDataFormatBuffer));
//
// Check that the stream number is valid
// We support only one capture pin/stream (index 0)
//
if (IntersectInfo->StreamNumber >= 1) {
Srb->Status = STATUS_NOT_IMPLEMENTED;
ERROR_LOG(("\'AdapterFormatFromRange: StreamNumber(=%d) is not implemented.\n", IntersectInfo->StreamNumber));
ASSERT(FALSE);
return FALSE;
}
//
// Get the pointer to the array of available formats
//
pAvailableFormats = &pDevExt->DCamStrmModes[0];
//
// Walk the formats supported by the stream searching for a match
// of the three GUIDs which together define a DATARANGE
//
DataRangeVideoToVerify = (PKS_DATARANGE_VIDEO) DataRange;
for (j = 0; j < pDevExt->ModeSupported; j++, pAvailableFormats++) {
DataRangeVideo = (PKS_DATARANGE_VIDEO) *pAvailableFormats;
//
// STREAM_DATA_INTERSECT_INFO
// [IN] ULONG StreamNumber;
// [IN] PKSDATARANGE DataRange;
// [OUT] PVOID DataFormatBuffer; // == PKS_DATAFORMAT_VIDEOINFOHEADER
// [OUT] ULONG SizeOfDataFormatBuffer;
//
//
// KS_DATAFORMAT_VIDEOINFOHEADER:
// fields marked with 'm' must match;
// marked with 'r' must within range;
// marked with 'f' is filled by us
//
// KSDATAFORMAT == KSDATARANGE
// m ULONG FormatSize;
// ULONG Flags;
// ULONG SampleSize;
// ULONG Reserved;
// m GUID MajorFormat;
// m GUID SubFormat;
// m GUID Specifier;.
// m BOOL bFixedSizeSamples; // all samples same size?
// m BOOL bTemporalCompression; // all I frames?
// m DWORD StreamDescriptionFlags; // KS_VIDEO_DESC_*
// m DWORD MemoryAllocationFlags; // KS_VIDEO_ALLOC_*
// m KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps;
// KS_VIDEOINFOHEADER
// RECT rcSource; // The bit we really want to use
// RECT rcTarget; // Where the video should go
// DWORD dwBitRate; // Approximate bit data rate
// DWORD dwBitErrorRate; // Bit error rate for this stream
// r/f REFERENCE_TIME AvgTimePerFrame; // Average time per frame (100ns units)
// KS_BITMAPINFOHEADER bmiHeader;
// DWORD biSize;
// m LONG biWidth;
// m LONG biHeight;
// WORD biPlanes;
// m WORD biBitCount;
// m DWORD biCompression;
// f DWORD biSizeImage;
// LONG biXPelsPerMeter;
// LONG biYPelsPerMeter;
// DWORD biClrUsed;
// DWORD biClrImportant;
//
// Verify that it is a VIDEO format/range.
if (!AdapterCompareGUIDsAndFormatSize((PKSDATARANGE)DataRangeVideoToVerify, (PKSDATARANGE)DataRangeVideo)) {
continue;
}
//
// It is valid video format/range; now check that the other fields match
//
if ((DataRangeVideoToVerify->bFixedSizeSamples != DataRangeVideo->bFixedSizeSamples) ||
(DataRangeVideoToVerify->bTemporalCompression != DataRangeVideo->bTemporalCompression) ||
(DataRangeVideoToVerify->StreamDescriptionFlags != DataRangeVideo->StreamDescriptionFlags) ||
(DataRangeVideoToVerify->MemoryAllocationFlags != DataRangeVideo->MemoryAllocationFlags) ||
(RtlCompareMemory (&DataRangeVideoToVerify->ConfigCaps, &DataRangeVideo->ConfigCaps, sizeof(KS_VIDEO_STREAM_CONFIG_CAPS)) != sizeof(KS_VIDEO_STREAM_CONFIG_CAPS))) {
continue;
}
//
// We do not support scaling or cropping so the dimension
// (biWidth, biHeight, biBitCount and biCompression)
// must match, and we will filled in the biSizeImage and others.
//
pbmiHeader = &DataRangeVideo->VideoInfoHeader.bmiHeader;
pbmiHeaderToVerify = &DataRangeVideoToVerify->VideoInfoHeader.bmiHeader;
if(pbmiHeader->biWidth != pbmiHeaderToVerify->biWidth ||
abs(pbmiHeader->biHeight) != abs(pbmiHeaderToVerify->biHeight) ||
pbmiHeader->biBitCount != pbmiHeaderToVerify->biBitCount ||
pbmiHeader->biCompression != pbmiHeaderToVerify->biCompression
) {
DbgMsg1(("AdapterFormatFromRange: Supported: %dx%dx%d [%x] != ToVerify: %dx%dx%d [%x]\n",
pbmiHeader->biWidth, pbmiHeader->biHeight, pbmiHeader->biBitCount, pbmiHeader->biCompression,
pbmiHeaderToVerify->biWidth, pbmiHeaderToVerify->biHeight, pbmiHeaderToVerify->biBitCount, pbmiHeaderToVerify->biCompression));
continue;
}
// MATCH FOUND!
MatchFound = TRUE;
// KS_DATAFORMAT_VIDEOINFOHEADER
// KSDATAFORMAT DataFormat;
// KS_VIDEOINFOHEADER VideoInfoHeader;
FormatSize = sizeof (KSDATAFORMAT) + KS_SIZE_VIDEOHEADER (&DataRangeVideo->VideoInfoHeader);
//
// 1st query: Srb->ActualBytesTransferred = FormatSize
//
if(IntersectInfo->SizeOfDataFormatBuffer == 0) {
Srb->Status = STATUS_BUFFER_OVERFLOW;
// We actually have not returned this much data,
// this "size" will be used by Ksproxy to send down
// a buffer of that size in next query.
Srb->ActualBytesTransferred = FormatSize;
break;
}
//
// 2nd time: pass back the format information
//
if (IntersectInfo->SizeOfDataFormatBuffer < FormatSize) {
Srb->Status = STATUS_BUFFER_TOO_SMALL;
DbgMsg2(("IntersectInfo->SizeOfDataFormatBuffer=%d, FormatSize=%d\n", IntersectInfo->SizeOfDataFormatBuffer, FormatSize));
return FALSE;
}
//
// A match is found, Copy from our supported/matched data range and set frame rate:
// KS_DATAFORMAT_VIDEOINFOHEADER
// KSDATAFORMAT DataFormat;
// KS_VIDEOINFOHEADER VideoInfoHeader;
//
RtlCopyMemory(
&((PKS_DATAFORMAT_VIDEOINFOHEADER)IntersectInfo->DataFormatBuffer)->DataFormat,
&DataRangeVideo->DataRange,
sizeof (KSDATAFORMAT));
RtlCopyMemory(
&((PKS_DATAFORMAT_VIDEOINFOHEADER) IntersectInfo->DataFormatBuffer)->VideoInfoHeader, // KS_VIDEOINFOHEADER
&DataRangeVideo->VideoInfoHeader, // KS_VIDEOINFOHEADER
KS_SIZE_VIDEOHEADER (&DataRangeVideo->VideoInfoHeader)); // Use KS_SIZE_VIDEOHEADER() since this is variable size
//
// Special atttention to these two fields: biSizeImage and AvgTimePerFrame.
// We do not scale or stretch so biSizeImage is fixed.
// However, AvgTimePerFrame (FrameRate) can/need to be within (ConfigCaps.MinFrameInterval, ConfigCaps.MaxFrameInterval)
//
if (DataRangeVideoToVerify->VideoInfoHeader.AvgTimePerFrame > DataRangeVideoToVerify->ConfigCaps.MaxFrameInterval ||
DataRangeVideoToVerify->VideoInfoHeader.AvgTimePerFrame < DataRangeVideoToVerify->ConfigCaps.MinFrameInterval) {
((PKS_DATAFORMAT_VIDEOINFOHEADER) IntersectInfo->DataFormatBuffer)->VideoInfoHeader.AvgTimePerFrame =
DataRangeVideo->VideoInfoHeader.AvgTimePerFrame;
DbgMsg2(("AdapterFormatFromRange: out of range; so set it to default (%ld)\n",DataRangeVideo->VideoInfoHeader.AvgTimePerFrame));
} else {
((PKS_DATAFORMAT_VIDEOINFOHEADER) IntersectInfo->DataFormatBuffer)->VideoInfoHeader.AvgTimePerFrame =
DataRangeVideoToVerify->VideoInfoHeader.AvgTimePerFrame;
}
((PKSDATAFORMAT)IntersectInfo->DataFormatBuffer)->FormatSize = FormatSize;
Srb->ActualBytesTransferred = FormatSize;
DbgMsg2(("AdapterFormatFromRange: match found: [%x], %dx%dx%d=%d, AvgTimePerFrame %ld\n",
pbmiHeader->biCompression, pbmiHeader->biWidth, pbmiHeader->biHeight, pbmiHeader->biBitCount, pbmiHeader->biSizeImage,
((PKS_DATAFORMAT_VIDEOINFOHEADER) IntersectInfo->DataFormatBuffer)->VideoInfoHeader.AvgTimePerFrame));
break;
} // End of loop on all formats for this stream
if(!MatchFound) {
DbgMsg2(("AdapterFormatFromRange: No match !!\n"));
Srb->Status = STATUS_NO_MATCH;
return FALSE;
}
return TRUE;
}
BOOL
DCamBuildFormatTable(
PDCAM_EXTENSION pDevExt,
PIRB pIrb
)
/*
Description:
Query Video format and mode supported by the camera.
Return:
TRUE: support at least one mode
FALSE: failed to read mode register or do not support any mode.
*/
{
// Initialize
pDevExt->ModeSupported = 0;
if(DCamGetVideoMode(pDevExt, pIrb)) {
#ifdef SUPPORT_YUV444
// Mode0: 160x120 (4:4:4)
if(pDevExt->DCamVModeInq0.VMode.Mode0 == 1 && pDevExt->DecoderDCamVModeInq0.VMode.Mode0 == 1) {
pDevExt->DCamStrmModes[pDevExt->ModeSupported] = (PKSDATAFORMAT) &DCAM_StreamMode_0;
pDevExt->ModeSupported++;
}
#endif
// Mode1: 320x240 (4:2:2)
if(pDevExt->DCamVModeInq0.VMode.Mode1 == 1 && pDevExt->DecoderDCamVModeInq0.VMode.Mode1 == 1) {
pDevExt->DCamStrmModes[pDevExt->ModeSupported] = (PKSDATAFORMAT) &DCAM_StreamMode_1;
pDevExt->ModeSupported++;
}
#ifdef SUPPORT_YUV411
// Mode2: 640x480 (4:1:1)
if(pDevExt->DCamVModeInq0.VMode.Mode2 == 1 && pDevExt->DecoderDCamVModeInq0.VMode.Mode2 == 1) {
pDevExt->DCamStrmModes[pDevExt->ModeSupported] = (PKSDATAFORMAT) &DCAM_StreamMode_2;
pDevExt->ModeSupported++;
}
#endif
// Mode3: 640x480 (4:2:2)
if(pDevExt->DCamVModeInq0.VMode.Mode3 == 1 && pDevExt->DecoderDCamVModeInq0.VMode.Mode3 == 1) {
pDevExt->DCamStrmModes[pDevExt->ModeSupported] = (PKSDATAFORMAT) &DCAM_StreamMode_3;
pDevExt->ModeSupported++;
}
#ifdef SUPPORT_RGB24
// Mode4: 640x480 (RGB24)
if(pDevExt->DCamVModeInq0.VMode.Mode4 == 1 && pDevExt->DecoderDCamVModeInq0.VMode.Mode4 == 1) {
pDevExt->DCamStrmModes[pDevExt->ModeSupported] = (PKSDATAFORMAT) &DCAM_StreamMode_4;
pDevExt->ModeSupported++;
}
#endif
#ifdef SUPPORT_YUV800
// Mode5: 640x480 (Y800)
if(pDevExt->DCamVModeInq0.VMode.Mode5 == 1 && pDevExt->DecoderDCamVModeInq0.VMode.Mode5 == 1) {
pDevExt->DCamStrmModes[pDevExt->ModeSupported] = (PKSDATAFORMAT) &DCAM_StreamMode_5;
pDevExt->ModeSupported++;
}
#endif
}
DbgMsg1(("\'Support %d modes; ->DCamStrmModes[]:%x\n", pDevExt->ModeSupported, &pDevExt->DCamStrmModes[0]));
ASSERT(pDevExt->ModeSupported > 0);
return (pDevExt->ModeSupported > 0);
}
/*
** VideoGetProperty()
**
** Routine to process video property requests
**
** Arguments:
**
** Srb - pointer to the stream request block for properties
**
** Returns:
**
** Side Effects: none
*/
VOID
VideoGetProperty(
PHW_STREAM_REQUEST_BLOCK Srb)
{
PSTREAM_PROPERTY_DESCRIPTOR pSPD = Srb->CommandData.PropertyInfo;
// preset to success
Srb->Status = STATUS_SUCCESS;
if (IsEqualGUID (&KSPROPSETID_Connection, &pSPD->Property->Set)) {
VideoStreamGetConnectionProperty (Srb);
} else if (IsEqualGUID (&PROPSETID_VIDCAP_DROPPEDFRAMES, &pSPD->Property->Set)) {
VideoStreamGetDroppedFramesProperty (Srb);
} else {
Srb->Status = STATUS_NOT_IMPLEMENTED;
}
}
/*
** VideoGetState()
**
** Gets the current state of the requested stream
**
** Arguments:
**
** Srb - pointer to the stream request block for properties
**
** Returns:
**
** Side Effects: none
*/
VOID
VideoGetState(
PHW_STREAM_REQUEST_BLOCK Srb)
{
PDCAM_EXTENSION pDevExt = (PDCAM_EXTENSION) Srb->HwDeviceExtension;
PSTREAMEX pStrmEx = pDevExt->pStrmEx;
PAGED_CODE();
DbgMsg2(("\'%d:%s) VideoGetState: KSSTATE=%s.\n",
pDevExt->idxDev, pDevExt->pchVendorName,
pStrmEx->KSState == KSSTATE_STOP ? "STOP" :
pStrmEx->KSState == KSSTATE_PAUSE ? "PAUSE" :
pStrmEx->KSState == KSSTATE_RUN ? "RUN" : "ACQUIRE"));
Srb->CommandData.StreamState = pStrmEx->KSState;
Srb->ActualBytesTransferred = sizeof (KSSTATE);
// A very odd rule:
// When transitioning from stop to pause, DShow tries to preroll
// the graph. Capture sources can't preroll, and indicate this
// by returning VFW_S_CANT_CUE in user mode. To indicate this
// condition from drivers, they must return ERROR_NO_DATA_DETECTED
Srb->Status = STATUS_SUCCESS;
if (pStrmEx->KSState == KSSTATE_PAUSE) {
Srb->Status = STATUS_NO_DATA_DETECTED;
}
}
VOID
VideoStreamGetConnectionProperty (
PHW_STREAM_REQUEST_BLOCK Srb)
{
PDCAM_EXTENSION pDevExt = (PDCAM_EXTENSION) Srb->HwDeviceExtension;
PSTREAM_PROPERTY_DESCRIPTOR pSPD = Srb->CommandData.PropertyInfo;
ULONG Id = pSPD->Property->Id; // index of the property
PSTREAMEX pStrmEx = (PSTREAMEX) pDevExt->pStrmEx;
ASSERT(pStrmEx == (PSTREAMEX)Srb->StreamObject->HwStreamExtension);
PAGED_CODE();
switch (Id) {
case KSPROPERTY_CONNECTION_ALLOCATORFRAMING:
if (pStrmEx->pVideoInfoHeader) {
PKSALLOCATOR_FRAMING Framing =
(PKSALLOCATOR_FRAMING) pSPD->PropertyInfo;
Framing->RequirementsFlags =
KSALLOCATOR_REQUIREMENTF_SYSTEM_MEMORY |
KSALLOCATOR_REQUIREMENTF_INPLACE_MODIFIER |
KSALLOCATOR_REQUIREMENTF_PREFERENCES_ONLY;
Framing->PoolType = PagedPool;
Framing->Frames = MAX_BUFFERS_SUPPLIED;
Framing->FrameSize = pStrmEx->pVideoInfoHeader->bmiHeader.biSizeImage;
Framing->FileAlignment = FILE_BYTE_ALIGNMENT; // 0: Basically no alignment by spec
Framing->Reserved = 0;
Srb->ActualBytesTransferred = sizeof (KSALLOCATOR_FRAMING);
Srb->Status = STATUS_SUCCESS;
DbgMsg2(("\'VideoStreamGetConnectionProperty: status=0x%x, Alignment %d, Frame %d, FrameSize %d\n",
Srb->Status, Framing->FileAlignment+1, Framing->Frames, Framing->FrameSize));
} else {
Srb->Status = STATUS_INVALID_PARAMETER;
DbgMsg2(("\'VideoStreamGetConnectionProperty: status=0x\n",Srb->Status));
}
break;
default:
ERROR_LOG(("VideoStreamGetConnectionProperty: Unsupported property id=%d\n",Id));
ASSERT(FALSE);
break;
}
}
/*
** VideoStreamGetConnectionProperty()
**
** Gets the current state of the requested stream
**
** Arguments:
**
** pSrb - pointer to the stream request block for properties
**
** Returns:
**
** Side Effects: none
*/
VOID
VideoStreamGetDroppedFramesProperty(
PHW_STREAM_REQUEST_BLOCK Srb
)
{
PSTREAMEX pStrmEx = (PSTREAMEX)Srb->StreamObject->HwStreamExtension;
PSTREAM_PROPERTY_DESCRIPTOR pSPD = Srb->CommandData.PropertyInfo;
ULONG Id = pSPD->Property->Id; // index of the property
ULONGLONG tmStream;
PAGED_CODE();
switch (Id) {
case KSPROPERTY_DROPPEDFRAMES_CURRENT:
{
PKSPROPERTY_DROPPEDFRAMES_CURRENT_S pDroppedFrames =
(PKSPROPERTY_DROPPEDFRAMES_CURRENT_S) pSPD->PropertyInfo;
if (pStrmEx->hMasterClock) {
tmGetStreamTime(Srb, pStrmEx, &tmStream);
if (tmStream < pStrmEx->FirstFrameTime) {
DbgMsg2(("\'*DroppedFP: Tm(%dms) < 1stFrameTm(%d)\n",
(LONG) tmStream/10000, (LONG)pStrmEx->FirstFrameTime));
pDroppedFrames->DropCount = 0;
} else {
pDroppedFrames->DropCount = (tmStream - pStrmEx->FirstFrameTime)
/ pStrmEx->pVideoInfoHeader->AvgTimePerFrame + 1 - pStrmEx->FrameCaptured;
}
if (pDroppedFrames->DropCount < 0)
pDroppedFrames->DropCount = 0;
} else {
pDroppedFrames->DropCount = 0;
}
// Update our drop frame here. "pDroppedFrames->DropCount" is return when a frame is returned.
if (pDroppedFrames->DropCount > pStrmEx->FrameInfo.DropCount) {
pStrmEx->FrameInfo.DropCount = pDroppedFrames->DropCount;
//pStrmEx->bDiscontinue = TRUE;
} else {
pDroppedFrames->DropCount = pStrmEx->FrameInfo.DropCount;
}
pDroppedFrames->AverageFrameSize = pStrmEx->pVideoInfoHeader->bmiHeader.biSizeImage;
pDroppedFrames->PictureNumber = pStrmEx->FrameCaptured + pDroppedFrames->DropCount;
// Correction if no picture has been successfully capture in the IsochCallback.
if (pDroppedFrames->PictureNumber < pDroppedFrames->DropCount)
pDroppedFrames->PictureNumber = pDroppedFrames->DropCount;
DbgMsg2(("\'*DroppedFP: tm(%d); Pic#(%d)=?Cap(%d)+Drp(%d)\n",
(ULONG) tmStream/10000,
(LONG) pDroppedFrames->PictureNumber,
(LONG) pStrmEx->FrameCaptured,
(LONG) pDroppedFrames->DropCount));
Srb->ActualBytesTransferred = sizeof (KSPROPERTY_DROPPEDFRAMES_CURRENT_S);
Srb->Status = STATUS_SUCCESS;
}
break;
default:
ERROR_LOG(("VideoStreamGetDroppedFramesProperty: Unsupported property id=%d\n",Id));
ASSERT(FALSE);
break;
}
}
VOID
VideoIndicateMasterClock(
PHW_STREAM_REQUEST_BLOCK Srb)
/*++
Routine Description:
Assign a master clock for this stream.
Arguments:
pSrb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
PDCAM_EXTENSION pDevExt = (PDCAM_EXTENSION) Srb->HwDeviceExtension;
PSTREAMEX pStrmEx = (PSTREAMEX) pDevExt->pStrmEx;
PAGED_CODE();
ASSERT(pStrmEx == (PSTREAMEX)Srb->StreamObject->HwStreamExtension);
pStrmEx->hMasterClock = Srb->CommandData.MasterClockHandle;
DbgMsg2(("\'%d:%s)VideoIndicateMasterClock: hMasterClock = 0x%x\n", pDevExt->idxDev, pDevExt->pchVendorName, pStrmEx->hMasterClock));
}
VOID
DCamReceivePacket(
IN PHW_STREAM_REQUEST_BLOCK pSrb
)
/*++
Routine Description:
This is where most of the interesting Stream requests come to us
Arguments:
pSrb - Pointer to Stream request block
Return Value:
Nothing
--*/
{
PIO_STACK_LOCATION IrpStack;
PDCAM_EXTENSION pDevExt = (PDCAM_EXTENSION) pSrb->HwDeviceExtension;
PAGED_CODE();
pSrb->Status = STATUS_SUCCESS;
//
// Switch on the command within the Srb itself
//
switch (pSrb->Command) {
case SRB_INITIALIZE_DEVICE: // Per device
pSrb->Status = DCamHwInitialize(pSrb);
break;
case SRB_INITIALIZATION_COMPLETE:
pSrb->Status = STATUS_NOT_IMPLEMENTED;
break;
case SRB_GET_STREAM_INFO: // Per Device
//
// this is a request for the driver to enumerate requested streams
//
DCamGetStreamInfo(pSrb);
break;
case SRB_OPEN_STREAM: // Per stream
DCamOpenStream(pSrb);
break;
case SRB_CLOSE_STREAM: // Per Stream
DbgMsg1((" #CLOSE_STREAM# (%d) camera: pSrb %x, pDevExt %x, pStrmEx %x, PendingRead %d\n",
pDevExt->idxDev, pSrb, pDevExt, pDevExt->pStrmEx, pDevExt->PendingReadCount));
DCamCloseStream(pSrb);
return; // SRB will finish asynchronously in its IoCompletionRoutine if there are pending reads to cancel.
case SRB_SURPRISE_REMOVAL:
DbgMsg1((" #SURPRISE_REMOVAL# (%d) camera: pSrb %x, pDevExt %x, pStrmEx %x, PendingRead %d\n",
pDevExt->idxDev, pSrb, pDevExt, pDevExt->pStrmEx, pDevExt->PendingReadCount));
DCamSurpriseRemoval(pSrb);
return; // SRB will finish asynchronously in its IoCompletionRoutine.
case SRB_UNKNOWN_DEVICE_COMMAND:
//
// We might be interested in unknown commands if they pertain
// to bus resets. We will reallocate resource (bandwidth and
// channel) if this device is streaming.
//
IrpStack = IoGetCurrentIrpStackLocation(pSrb->Irp);
if (IrpStack->MajorFunction == IRP_MJ_PNP)
DCamProcessPnpIrp(pSrb, IrpStack, pDevExt);
else
pSrb->Status = STATUS_NOT_IMPLEMENTED;
break;
case SRB_UNINITIALIZE_DEVICE: // Per device
DbgMsg1((" #UNINITIALIZE_DEVICE# (%d) %s camera : pSrb %x, pDevExt %x, pStrmEx %x\n",
pDevExt->idxDev, pDevExt->pchVendorName, pSrb, pDevExt, pDevExt->pStrmEx));
pSrb->Status = DCamHwUnInitialize(pSrb);
break;
case SRB_GET_DATA_INTERSECTION:
//
// Return a format, given a range
//
AdapterFormatFromRange(pSrb);
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
return;
case SRB_CHANGE_POWER_STATE:
DCamChangePower(pSrb);
break;
// VideoProcAmp and CameraControl requests
case SRB_GET_DEVICE_PROPERTY:
AdapterGetProperty(pSrb);
break;
case SRB_SET_DEVICE_PROPERTY:
AdapterSetProperty(pSrb);
break;
case SRB_PAGING_OUT_DRIVER:
// Once we register bus reset, we can be called at any time;
// So we cannot page out.
pSrb->Status = STATUS_NOT_IMPLEMENTED;
break;
default:
DbgMsg1(("DCamReceivePacket: entry with unknown and unsupported SRB command 0x%x\n", pSrb->Command));
//
// this is a request that we do not understand. Indicate invalid
// command and complete the request
//
pSrb->Status = STATUS_NOT_IMPLEMENTED;
break;
}
//
// NOTE:
//
// all of the commands that we do, or do not understand can all be completed
// synchronously at this point, so we can use a common callback routine here.
// If any of the above commands require asynchronous processing, this will
// have to change
//
#if DBG
if (pSrb->Status != STATUS_SUCCESS &&
pSrb->Status != STATUS_NOT_IMPLEMENTED) {
DbgMsg1(("pSrb->Command(0x%x) does not return STATUS_SUCCESS or NOT_IMPLEMENTED but 0x%x\n", pSrb->Command, pSrb->Status));
}
#endif
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
}
Reference in a new issue View git blame Copy permalink