crossbar.cpp

通用摄像头驱动的应用程序部分

            for (k = 0; k < Depth; k++) 
            {
                ASSERT (pCurrent->pXbar != NULL);

                // Release the crossbar interface
                pCurrent->pXbar->Release();

                // Move to the next node in the list
                pCurrent = pCurrent->pRightRouting;
            }
        }
        
        delete [] pFirst;
    }

    return S_OK;
}


//
// Does not AddRef the returned *Pin 
//
HRESULT CCrossbar::GetCrossbarIPinAtIndex(
   IAMCrossbar *pXbar,
   LONG PinIndex,
   BOOL IsInputPin,
   IPin ** ppPin)
{
    LONG         cntInPins, cntOutPins;
    IPin        *pP = 0;
    IBaseFilter *pFilter = NULL;
    IEnumPins   *pins=0;
    ULONG        n;
    HRESULT      hr;

    if (!pXbar || !ppPin)
        return E_POINTER;

    *ppPin = 0;

    if(S_OK != pXbar->get_PinCounts(&cntOutPins, &cntInPins))
        return E_FAIL;

    LONG TrueIndex = IsInputPin ? PinIndex : PinIndex + cntInPins;

    hr = pXbar->QueryInterface(IID_IBaseFilter, (void **)&pFilter);

    if (hr == S_OK) 
    {
        if(SUCCEEDED(pFilter->EnumPins(&pins))) 
        {
            LONG i=0;
            while(pins->Next(1, &pP, &n) == S_OK) 
            {
                pP->Release();
                if (i == TrueIndex) 
                {
                    *ppPin = pP;
                    break;
                }
                i++;
            }
            pins->Release();
        }
        pFilter->Release();
    }
    
    return *ppPin ? S_OK : E_FAIL; 
}


//
// Find corresponding index of an IPin on a crossbar
//
HRESULT CCrossbar::GetCrossbarIndexFromIPin (
    IAMCrossbar * pXbar,
    LONG * PinIndex,
    BOOL IsInputPin,
    IPin * pPin)
{
    LONG         cntInPins, cntOutPins;
    IPin        *pP = 0;
    IBaseFilter *pFilter = NULL;
    IEnumPins   *pins = 0;
    ULONG        n;
    BOOL         fOK = FALSE;
    HRESULT      hr;

    if (!pXbar || !PinIndex || !pPin)
        return E_POINTER;

    if(S_OK != pXbar->get_PinCounts(&cntOutPins, &cntInPins))
        return E_FAIL;

    hr = pXbar->QueryInterface(IID_IBaseFilter, (void **)&pFilter);

    if (hr == S_OK) 
    {
        if(SUCCEEDED(pFilter->EnumPins(&pins))) 
        {
            LONG i=0;
        
            while(pins->Next(1, &pP, &n) == S_OK) 
            {
                pP->Release();
                if (pPin == pP) 
                {
                    *PinIndex = IsInputPin ? i : i - cntInPins;
                    fOK = TRUE;
                    break;
                }
                i++;
            }
            pins->Release();
        }
        pFilter->Release();
    }
    
    return fOK ? S_OK : E_FAIL; 
}


//
// How many unique video inputs can be selected?
//
HRESULT CCrossbar::GetInputCount (LONG *pCount)
{
    if (pCount && m_RoutingList)
    {
        *pCount = m_RoutingList->GetCount();
        return S_OK;
    }
    else
        return E_POINTER;
}


//
// What is the physical type of a given input?
//
HRESULT CCrossbar::GetInputType (
    LONG Index, 
    LONG * plPhysicalType)
{
    if (!plPhysicalType || !m_RoutingList)
        return E_POINTER;

    CRouting *pCurrent = m_RoutingList->GetHead();

    if (Index >= m_RoutingList->GetCount()) {
        return E_FAIL;
    }

    POSITION pos = m_RoutingList->GetHeadPosition();

    for (int j = 0; j <= Index; j++) {  
       pCurrent = m_RoutingList->GetNext(pos);
    }
    ASSERT (pCurrent != NULL);

    *plPhysicalType = pCurrent->InputPhysicalType;

    return S_OK;
}


//
// Converts a PinType into a String
//
BOOL  CCrossbar::StringFromPinType (TCHAR *pc, int nSize, long lType)
{
    TCHAR *pcT;
    BOOL bSuccess;

    if (!pc || !nSize)
        return FALSE;

    switch (lType) 
    {   
        case PhysConn_Video_Tuner:           pcT = TEXT("Video Tuner\0");          break;
        case PhysConn_Video_Composite:       pcT = TEXT("Video Composite\0");      break;
        case PhysConn_Video_SVideo:          pcT = TEXT("Video SVideo\0");         break;
        case PhysConn_Video_RGB:             pcT = TEXT("Video RGB\0");            break;
        case PhysConn_Video_YRYBY:           pcT = TEXT("Video YRYBY\0");          break;
        case PhysConn_Video_SerialDigital:   pcT = TEXT("Video SerialDigital\0");  break;
        case PhysConn_Video_ParallelDigital: pcT = TEXT("Video ParallelDigital\0");break;
        case PhysConn_Video_SCSI:            pcT = TEXT("Video SCSI\0");           break;
        case PhysConn_Video_AUX:             pcT = TEXT("Video AUX\0");            break;
        case PhysConn_Video_1394:            pcT = TEXT("Video 1394\0");           break;
        case PhysConn_Video_USB:             pcT = TEXT("Video USB\0");            break;
        case PhysConn_Video_VideoDecoder:    pcT = TEXT("Video Decoder\0");        break;
        case PhysConn_Video_VideoEncoder:    pcT = TEXT("Video Encoder\0");        break;
    
        case PhysConn_Audio_Tuner:           pcT = TEXT("Audio Tuner\0");          break;
        case PhysConn_Audio_Line:            pcT = TEXT("Audio Line\0");           break;
        case PhysConn_Audio_Mic:             pcT = TEXT("Audio Mic\0");            break;
        case PhysConn_Audio_AESDigital:      pcT = TEXT("Audio AESDigital\0");     break;
        case PhysConn_Audio_SPDIFDigital:    pcT = TEXT("Audio SPDIFDigital\0");   break;
        case PhysConn_Audio_SCSI:            pcT = TEXT("Audio SCSI\0");           break;
        case PhysConn_Audio_AUX:             pcT = TEXT("Audio AUX\0");            break;
        case PhysConn_Audio_1394:            pcT = TEXT("Audio 1394\0");           break;
        case PhysConn_Audio_USB:             pcT = TEXT("Audio USB\0");            break;
        case PhysConn_Audio_AudioDecoder:    pcT = TEXT("Audio Decoder\0");        break;
    
        default:
            pcT = TEXT("Unknown\0");
            break;
    }
    
    // return TRUE on sucessful copy
    if (lstrcpyn (pc, pcT, nSize) != NULL)
        bSuccess = TRUE;
    else
        bSuccess = FALSE;
    
    return (bSuccess);
}


//
// Get a text version of an input
//
// Return S_OK if the buffer is large enough to copy the string name
//
HRESULT CCrossbar::GetInputName (
    LONG   Index, 
    TCHAR *pName, 
    LONG   Size)
{
    if (!m_RoutingList)
        return E_POINTER;

    CRouting *pCurrent = m_RoutingList->GetHead();

    if ((Index >= m_RoutingList->GetCount()) || (pName == NULL)) {
        return E_FAIL;
    }

    POSITION pos = m_RoutingList->GetHeadPosition();

    for (int j = 0; j <= Index; j++) { 
       pCurrent = m_RoutingList->GetNext(pos);
    }
    ASSERT (pCurrent != NULL);

    return (StringFromPinType (pName, Size, pCurrent->InputPhysicalType) ?
            S_OK : E_FAIL);
}


//
// Select an input 
//
HRESULT CCrossbar::SetInputIndex (
    LONG Index)
{
    HRESULT hr = E_FAIL;

    if (!m_RoutingList)
        return E_POINTER;

    CRouting *pCurrent = m_RoutingList->GetHead();
    int j;

    if (Index >= m_RoutingList->GetCount())
        return hr;

    POSITION pos = m_RoutingList->GetHeadPosition();
    for (j = 0; j <= Index; j++) { 
       pCurrent = m_RoutingList->GetNext(pos);
    }

    ASSERT (pCurrent != NULL);

    int Depth= pCurrent->Depth + 1;

    for (j = 0; j < Depth; j++) 
    {
        hr = pCurrent->pXbar->Route (pCurrent->VideoOutputIndex, pCurrent->VideoInputIndex);
        ASSERT (S_OK == hr);

        if ((pCurrent->AudioOutputIndex != -1) && (pCurrent->AudioInputIndex != -1)) {
            EXECUTE_ASSERT (S_OK == pCurrent->pXbar->Route (pCurrent->AudioOutputIndex, 
                            pCurrent->AudioInputIndex));
        }

        DbgLog((LOG_TRACE,3,TEXT("CCrossbar::Routing, VideoOutIndex=%d VideoInIndex=%d"), 
                pCurrent->VideoOutputIndex, pCurrent->VideoInputIndex));

        pCurrent++;
    }

    m_CurrentRoutingIndex = Index;

    return hr;
}


//
// What input is currently selected?
//
HRESULT CCrossbar::GetInputIndex (
    LONG *plIndex)
{
    if (plIndex)
    {    
        *plIndex = m_CurrentRoutingIndex;
        return S_OK;
    }
    else
        return E_POINTER;
}