Trabajar con dispositivos de vídeo USB DV
[La característica asociada a esta página, DirectShow, es una característica heredada. Se ha reemplazado por MediaPlayer, IMFMediaEngine y Captura de audio/vídeo en Media Foundation. Esas características se han optimizado para Windows 10 y Windows 11. Microsoft recomienda encarecidamente que el nuevo código use MediaPlayer, IMFMediaEngine y Audio/Video Capture en Media Foundation en lugar de DirectShow, siempre que sea posible. Microsoft sugiere que el código existente que usa las API heredadas se reescriba para usar las nuevas API si es posible.
En este tema se describe cómo escribir aplicaciones para dispositivos de vídeo Universal Serial Bus (USB) que capturan vídeo DV.
El formato DV estándar tiene una velocidad de datos de aproximadamente 25 megabits por segundo (Mbps). Cuando se introdujo por primera vez USB, no tenía suficiente ancho de banda para admitir vídeo DV. Sin embargo, USB 2.0 puede admitir hasta 480 Mbps, que es más que suficiente para el vídeo DV. La especificación USB Video Device Class (UVC), publicada en 2003, define el formato de carga para dispositivos de vídeo USB DV. Se introdujo un controlador de clase de modelo de controlador de Windows (WDM) para dispositivos UVC en Windows XP Service Pack 2.
En la mayoría de los aspectos, el controlador UVC admite el mismo modelo de programación que el controlador MSDV para dispositivos IEEE 1394. Las aplicaciones escritas para MSDV solo deben requerir modificaciones menores para admitir dispositivos UVC.
El controlador UVC se comporta de forma diferente del controlador MSDV en las siguientes áreas:
- Modo de dispositivo
- Formato de secuencia
- Formato de señal
- Búsqueda de ubicación de cinta
- Transmitir DV de archivo a cinta.
Para determinar qué controlador se usa, llame a IAMExtDevice::get_DevicePort. El controlador MSDV devuelve la marca DEV_PORT_1394 y el controlador UVC devuelve la marca DEV_PORT_USB.
Nodos de dispositivo
En la terminología usb, los puntos de conexión son los puntos en los que los datos entran o salen del dispositivo. Un punto de conexión tiene una dirección del flujo de datos, ya sea entrada (desde el dispositivo al host) o la salida (del host al dispositivo). Puede ayudar a pensar en estas direcciones como relativas al host. La entrada va al host; la salida procede del host. En el diagrama siguiente se muestran los dos puntos de conexión.
En un dispositivo UVC, las funciones del dispositivo se dividen lógicamente en componentes denominados unidades y terminales. Una unidad recibe uno o varios flujos de datos como entrada y entrega exactamente un flujo como salida. Un terminal es el punto inicial o el punto final de un flujo de datos. Los puntos de conexión USB corresponden a terminales, pero las direcciones se invierten: un punto de conexión de entrada se representa mediante un terminal de salida y viceversa. En el diagrama siguiente se muestra la relación entre los terminales y los puntos de conexión.
Además, no todos los terminales corresponden a un punto de conexión USB. El término punto de conexión hace referencia específicamente a las conexiones USB y un dispositivo puede enviar o recibir datos a través de conexiones no USB. Por ejemplo, una cámara de vídeo es un terminal de entrada y una pantalla LCD es un terminal de salida.
En el filtro KS Proxy, las unidades y los terminales se representan como nodos dentro del filtro. El término nodo es más general que la unidad de términos y el terminal porque los dispositivos que no son USB también pueden tener nodos. Para obtener información sobre los nodos de un filtro, consulte el filtro de la interfaz IKsTopologyInfo . Los tipos de nodo se identifican mediante GUID. Los nodos de selector son nodos que pueden cambiar entre dos o más entradas. Los nodos de selector exponen la interfaz ISelector .
El código siguiente comprueba si un pin de salida de un filtro recibe la entrada de un nodo de un tipo determinado.
// Structure to hold topology information.
struct TopologyConnections
{
KSTOPOLOGY_CONNECTION *connections; // Array of connections
DWORD count; // Number of elements in the array
};
/////////////////////////////////////////////////////////////////////
// Name: GetTopologyConnections
// Desc: Gets the topology information from a filter.
//
// pTopo: Pointer to the filter's IKsTopologyInfo interface.
// connectInfo: Pointer to a TopologyConnections structure. The
// function fills in this structure.
//
// Note: If the function succeeds, call CoTaskMemFree to free the
// pConnectInfo->connections array.
/////////////////////////////////////////////////////////////////////
HRESULT GetTopologyConnections(
IKsTopologyInfo *pTopo,
TopologyConnections *pConnectInfo
)
{
DWORD count;
HRESULT hr = pTopo->get_NumConnections(&count);
if (FAILED(hr))
{
return hr;
}
pConnectInfo->count = count;
pConnectInfo->connections = NULL;
if (count > 0)
{
// Allocate an array for the connection information.
SIZE_T cb = sizeof(KSTOPOLOGY_CONNECTION) * count;
KSTOPOLOGY_CONNECTION *pConnections =
(KSTOPOLOGY_CONNECTION*) CoTaskMemAlloc(cb);
if (pConnections == NULL)
{
return E_OUTOFMEMORY;
}
// Fill the array.
for (DWORD ix = 0; ix < count; ix++)
{
hr = pTopo->get_ConnectionInfo(ix, &pConnections[ix]);
if (FAILED(hr))
{
break;
}
}
if (SUCCEEDED(hr))
{
pConnectInfo->connections = pConnections;
}
else
{
CoTaskMemFree(pConnections);
}
}
return hr;
}
/////////////////////////////////////////////////////////////////////
// Name: IsNodeDownstreamFromNode
// Desc: Searches upstream from a node for a specified node type.
//
// pTopo: Pointer to the filter's IKsTopologyInfo interface.
// connectInfo: Contains toplogy information. To fill in this
// structure, call GetTopologyConnections.
// nodeID: ID of the starting node in the search.
// nodeType: Type of node to find.
// pIsConnected: Receives true if connected, or false otherwise.
//
// Note: If the source node matches the type, this function returns
// true without searching upstream.
/////////////////////////////////////////////////////////////////////
HRESULT IsNodeDownstreamFromNode(
IKsTopologyInfo *pTopo,
const TopologyConnections& connectInfo,
DWORD nodeID,
const GUID& nodeType,
bool *pIsConnected
)
{
*pIsConnected = false;
// Base case for recursion: check the source node.
GUID type;
HRESULT hr = pTopo->get_NodeType(nodeID, &type);
if (FAILED(hr))
{
return hr;
}
if (type == nodeType)
{
*pIsConnected = true;
return S_OK;
}
// If the source node is a selector, get the input node.
CComPtr<ISelector> pSelector;
hr = pTopo->CreateNodeInstance(nodeID, __uuidof(ISelector),
(void**)&pSelector);
if (SUCCEEDED(hr))
{
DWORD sourceNodeID;
hr = pSelector->get_SourceNodeId(&sourceNodeID);
if (SUCCEEDED(hr))
{
// Recursive call with the selector's input node.
return IsNodeDownstreamFromNode(pTopo, connectInfo,
sourceNodeID, nodeType, pIsConnected);
}
}
else if (hr == E_NOINTERFACE)
{
hr = S_OK; // This node is not a selector. Not a failure.
}
else
{
return hr;
}
// Test all of the upstream connections on this pin.
for (DWORD ix = 0; ix < connectInfo.count; ix++)
{
if ((connectInfo.connections[ix].ToNode == nodeID) &&
(connectInfo.connections[ix].FromNode != KSFILTER_NODE))
{
// FromNode is connected to the source node.
DWORD fromNode = connectInfo.connections[ix].FromNode;
// Recursive call with the upstream node.
bool bIsConnected;
hr = IsNodeDownstreamFromNode(pTopo, connectInfo,
fromNode, nodeType, &bIsConnected);
if (FAILED(hr))
{
break;
}
if (bIsConnected)
{
*pIsConnected = true;
break;
}
}
}
return hr;
}
/////////////////////////////////////////////////////////////////////
// Name: GetNodeUpstreamFromPin
// Desc: Finds the node connected to an output pin.
//
// connectInfo: Contains toplogy information. To fill in this
// structure, call GetTopologyConnections.
// nPinIndex: Index of the output pin.
// pNodeID: Receives the ID of the connected node.
/////////////////////////////////////////////////////////////////////
HRESULT GetNodeUpstreamFromPin(
const TopologyConnections& connectInfo,
UINT nPinIndex,
DWORD *pNodeID
)
{
bool bFound = false;
for (DWORD ix = 0; ix < connectInfo.count; ix++)
{
if ((connectInfo.connections[ix].ToNode == KSFILTER_NODE) &&
(connectInfo.connections[ix].ToNodePin == nPinIndex))
{
*pNodeID = connectInfo.connections[ix].FromNode;
bFound = true;
break;
}
}
if (bFound)
{
return S_OK;
}
else
{
return E_FAIL;
}
}
/////////////////////////////////////////////////////////////////////
// Name: IsPinDownstreamFromNode
// Desc: Tests whether an output pin gets data from a node of
// a specified type.
//
// pFilter: Pointer to the filter's IBaseFilter interface.
// UINT: Index of the output pin to test.
// nodeType: Type of node to find.
// pIsConnected: Receives true if connected; false otherwise.
/////////////////////////////////////////////////////////////////////
HRESULT IsPinDownstreamFromNode(
IBaseFilter *pFilter,
UINT nPinIndex,
const GUID& nodeType,
bool *pIsConnected
)
{
CComQIPtr<IKsTopologyInfo> pTopo(pFilter);
if (pTopo == NULL)
{
return E_NOINTERFACE;
}
// Get the topology connection information.
TopologyConnections connectionInfo;
HRESULT hr = GetTopologyConnections(pTopo, &connectionInfo);
if (FAILED(hr))
{
return hr;
}
// Find the node upstream from this pin.
DWORD nodeID;
hr = GetNodeUpstreamFromPin(connectionInfo, nPinIndex, &nodeID);
if (SUCCEEDED(hr))
{
bool isConnected;
hr = IsNodeDownstreamFromNode(pTopo, connectionInfo,
nodeID, nodeType, &isConnected);
if (SUCCEEDED(hr))
{
*pIsConnected = isConnected;
}
}
CoTaskMemFree(connectionInfo.connections);
return hr;
}
Temas relacionados
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de