wxdebug.cpp

basic class basic classbasic class

void WINAPI DbgDumpObjectRegister()
{
    TCHAR szInfo[iDEBUGINFO];
    
    /* Grab the list critical section */
    
    EnterCriticalSection(&m_CSDebug);
    ObjectDesc *pObject = pListHead;
    
    /* Scan the object list displaying the name and cookie */
    
    DbgLog((LOG_MEMORY,2,TEXT("")));
    DbgLog((LOG_MEMORY,2,TEXT("   ID             Object Description")));
    DbgLog((LOG_MEMORY,2,TEXT("")));
    
    while (pObject) {
        wsprintf(szInfo,TEXT("%5d (%p) %30s"),pObject->m_dwCookie, &pObject, pObject->m_pName);
        DbgLog((LOG_MEMORY,2,szInfo));
        pObject = pObject->m_pNext;
    }
    
    wsprintf(szInfo,TEXT("Total object count %5d"),m_dwObjectCount);
    DbgLog((LOG_MEMORY,2,TEXT("")));
    DbgLog((LOG_MEMORY,1,szInfo));
    LeaveCriticalSection(&m_CSDebug);
}


/*  Debug infinite wait stuff */
DWORD WINAPI DbgWaitForSingleObject(HANDLE h)
{
    DWORD dwWaitResult;
    do {
        dwWaitResult = WaitForSingleObject(h, dwWaitTimeout);
        ASSERT(dwWaitResult == WAIT_OBJECT_0);
    } while (dwWaitResult == WAIT_TIMEOUT);
    return dwWaitResult;
}


DWORD WINAPI DbgWaitForMultipleObjects(DWORD nCount,
                                       CONST HANDLE *lpHandles,
                                       BOOL bWaitAll)
{
    DWORD dwWaitResult;
    do {
        dwWaitResult = WaitForMultipleObjects(nCount,
            lpHandles,
            bWaitAll,
            dwWaitTimeout);
        ASSERT((DWORD)(dwWaitResult - WAIT_OBJECT_0) < MAXIMUM_WAIT_OBJECTS);
    } while (dwWaitResult == WAIT_TIMEOUT);
    return dwWaitResult;
}

void WINAPI DbgSetWaitTimeout(DWORD dwTimeout)
{
    dwWaitTimeout = dwTimeout;
}

#endif /* DEBUG */

#ifdef _OBJBASE_H_

/*  Stuff for printing out our GUID names */

GUID_STRING_ENTRY g_GuidNames[] = {
#define OUR_GUID_ENTRY(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
    { TEXT(#name), { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } } },
#include <uuids.h>
};

CGuidNameList GuidNames;
int g_cGuidNames = sizeof(g_GuidNames) / sizeof(g_GuidNames[0]);

TCHAR *CGuidNameList::operator [] (const GUID &guid)
{
    for (int i = 0; i < g_cGuidNames; i++) {
        if (g_GuidNames[i].guid == guid) {
            return g_GuidNames[i].szName;
        }
    }
    if (guid == GUID_NULL) {
        return TEXT("GUID_NULL");
    }
    
    // !!! add something to print FOURCC guids?
    
    // shouldn't this print the hex CLSID?
    return TEXT("Unknown GUID Name");
}

#endif /* _OBJBASE_H_ */

/*  CDisp class - display our data types */

// clashes with REFERENCE_TIME
CDisp::CDisp(LONGLONG ll, int Format)
{
    // note: this could be combined with CDisp(LONGLONG) by
    // introducing a default format of CDISP_REFTIME
    LARGE_INTEGER li;
    li.QuadPart = ll;
    switch (Format) {
    case CDISP_DEC:
        {
            TCHAR  temp[20];
            int pos=20;
            temp[--pos] = 0;
            int digit;
            // always output at least one digit
            do {
                // Get the rightmost digit - we only need the low word
                digit = li.LowPart % 10;
                li.QuadPart /= 10;
                temp[--pos] = (TCHAR) digit+L'0';
            } while (li.QuadPart);
            wsprintf(m_String, TEXT("%s"), temp+pos);
            break;
        }
    case CDISP_HEX:
    default:
        wsprintf(m_String, TEXT("0x%X%8.8X"), li.HighPart, li.LowPart);
    }
};

CDisp::CDisp(REFCLSID clsid)
{
    WCHAR strClass[CHARS_IN_GUID+1];
    StringFromGUID2(clsid, strClass, sizeof(strClass) / sizeof(strClass[0]));
    ASSERT(sizeof(m_String)/sizeof(m_String[0]) >= CHARS_IN_GUID+1);
    wsprintf(m_String, TEXT("%ls"), strClass);
};

/*  Display stuff */
CDisp::CDisp(CRefTime llTime)
{
    LPTSTR lpsz = m_String;
    LONGLONG llDiv;
    if (llTime < 0) {
        llTime = -llTime;
        lpsz += wsprintf(lpsz, TEXT("-"));
    }
    llDiv = (LONGLONG)24 * 3600 * 10000000;
    if (llTime >= llDiv) {
        lpsz += wsprintf(lpsz, TEXT("%d days "), (LONG)(llTime / llDiv));
        llTime = llTime % llDiv;
    }
    llDiv = (LONGLONG)3600 * 10000000;
    if (llTime >= llDiv) {
        lpsz += wsprintf(lpsz, TEXT("%d hrs "), (LONG)(llTime / llDiv));
        llTime = llTime % llDiv;
    }
    llDiv = (LONGLONG)60 * 10000000;
    if (llTime >= llDiv) {
        lpsz += wsprintf(lpsz, TEXT("%d mins "), (LONG)(llTime / llDiv));
        llTime = llTime % llDiv;
    }
    wsprintf(lpsz, TEXT("%d.%3.3d sec"),
        (LONG)llTime / 10000000,
        (LONG)((llTime % 10000000) / 10000));
};

/*  Display pin */
CDisp::CDisp(IPin *pPin)
{
    PIN_INFO pi;
    TCHAR str[MAX_PIN_NAME];
    if (pPin) {
        pPin->QueryPinInfo(&pi);
        QueryPinInfoReleaseFilter(pi);
#ifndef UNICODE
        WideCharToMultiByte(GetACP(), 0, pi.achName, lstrlenW(pi.achName) + 1,
            str, MAX_PIN_NAME, NULL, NULL);
#else
        lstrcpy(str, pi.achName);
#endif
    } else {
        lstrcpy(str, TEXT("NULL IPin"));
    }
    
    m_pString = (PTCHAR) new TCHAR[lstrlen(str)+64];
    if (!m_pString) {
        return;
    }
    
    if (pPin) {
        CLSID clsid;
        pi.pFilter->GetClassID(&clsid);
        wsprintf(m_pString, TEXT("%s(%s)"), GuidNames[clsid], str);
    }
}

CDisp::~CDisp()
{
}

CDispBasic::~CDispBasic()
{
    if (m_pString != m_String) {
        delete [] m_pString;
    }
}

CDisp::CDisp(double d)
{
#ifdef DEBUG
#ifndef UNDER_CE
    _stprintf(m_String, TEXT("%.16g"), d);
#else
    wsprintf(m_String, TEXT("%.16g"), d);
#endif // UNDER_CE
#else
    wsprintf(m_String, TEXT("%d.%03d"), (int) d, (int) ((d - (int) d) * 1000));
#endif
}


/* If built for debug this will display the media type details. We convert the
major and subtypes into strings and also ask the base classes for a string
description of the subtype, so MEDIASUBTYPE_RGB565 becomes RGB 565 16 bit
We also display the fields in the BITMAPINFOHEADER structure, this should
succeed as we do not accept input types unless the format is big enough */

#ifdef DEBUG
void WINAPI DisplayType(LPSTR label, const AM_MEDIA_TYPE *pmtIn)
{
    
    /* Dump the GUID types and a short description */
    
    DbgLog((LOG_TRACE,5,TEXT("")));
    DbgLog((LOG_TRACE,2,TEXT("%hs  M type %s  S type %s"), label,
        GuidNames[pmtIn->majortype],
        GuidNames[pmtIn->subtype]));
    DbgLog((LOG_TRACE,5,TEXT("Subtype description %s"),GetSubtypeName(&pmtIn->subtype)));
    
    /* Dump the generic media types */
    
    if (pmtIn->bTemporalCompression) {
        DbgLog((LOG_TRACE,5,TEXT("Temporally compressed")));
    } else {
        DbgLog((LOG_TRACE,5,TEXT("Not temporally compressed")));
    }
    
    if (pmtIn->bFixedSizeSamples) {
        DbgLog((LOG_TRACE,5,TEXT("Sample size %d"),pmtIn->lSampleSize));
    } else {
        DbgLog((LOG_TRACE,5,TEXT("Variable size samples")));
    }
    
    if (pmtIn->formattype == FORMAT_VideoInfo) {
        /* Dump the contents of the BITMAPINFOHEADER structure */
        BITMAPINFOHEADER *pbmi = HEADER(pmtIn->pbFormat);
        VIDEOINFOHEADER *pVideoInfo = (VIDEOINFOHEADER *)pmtIn->pbFormat;
        
        DbgLog((LOG_TRACE,5,TEXT("Source rectangle (Left %d Top %d Right %d Bottom %d)"),
            pVideoInfo->rcSource.left,
            pVideoInfo->rcSource.top,
            pVideoInfo->rcSource.right,
            pVideoInfo->rcSource.bottom));
        
        DbgLog((LOG_TRACE,5,TEXT("Target rectangle (Left %d Top %d Right %d Bottom %d)"),
            pVideoInfo->rcTarget.left,
            pVideoInfo->rcTarget.top,
            pVideoInfo->rcTarget.right,
            pVideoInfo->rcTarget.bottom));
        
        DbgLog((LOG_TRACE,5,TEXT("Size of BITMAPINFO structure %d"),pbmi->biSize));
        if (pbmi->biCompression < 256) {
            DbgLog((LOG_TRACE,2,TEXT("%dx%dx%d bit  (%d)"),
                pbmi->biWidth, pbmi->biHeight,
                pbmi->biBitCount, pbmi->biCompression));
        } else {
            DbgLog((LOG_TRACE,2,TEXT("%dx%dx%d bit '%4.4hs'"),
                pbmi->biWidth, pbmi->biHeight,
                pbmi->biBitCount, &pbmi->biCompression));
        }
        
        DbgLog((LOG_TRACE,2,TEXT("Image size %d"),pbmi->biSizeImage));
        DbgLog((LOG_TRACE,5,TEXT("Planes %d"),pbmi->biPlanes));
        DbgLog((LOG_TRACE,5,TEXT("X Pels per metre %d"),pbmi->biXPelsPerMeter));
        DbgLog((LOG_TRACE,5,TEXT("Y Pels per metre %d"),pbmi->biYPelsPerMeter));
        DbgLog((LOG_TRACE,5,TEXT("Colours used %d"),pbmi->biClrUsed));
        
    } else if (pmtIn->majortype == MEDIATYPE_Audio) {
        DbgLog((LOG_TRACE,2,TEXT("     Format type %s"),
            GuidNames[pmtIn->formattype]));
        DbgLog((LOG_TRACE,2,TEXT("     Subtype %s"),
            GuidNames[pmtIn->subtype]));
        
        if ((pmtIn->subtype != MEDIASUBTYPE_MPEG1Packet)
            && (pmtIn->cbFormat >= sizeof(PCMWAVEFORMAT)))
        {
            /* Dump the contents of the WAVEFORMATEX type-specific format structure */
            
            WAVEFORMATEX *pwfx = (WAVEFORMATEX *) pmtIn->pbFormat;
            DbgLog((LOG_TRACE,2,TEXT("wFormatTag %u"), pwfx->wFormatTag));
            DbgLog((LOG_TRACE,2,TEXT("nChannels %u"), pwfx->nChannels));
            DbgLog((LOG_TRACE,2,TEXT("nSamplesPerSec %lu"), pwfx->nSamplesPerSec));
            DbgLog((LOG_TRACE,2,TEXT("nAvgBytesPerSec %lu"), pwfx->nAvgBytesPerSec));
            DbgLog((LOG_TRACE,2,TEXT("nBlockAlign %u"), pwfx->nBlockAlign));
            DbgLog((LOG_TRACE,2,TEXT("wBitsPerSample %u"), pwfx->wBitsPerSample));
            
            /* PCM uses a WAVEFORMAT and does not have the extra size field */
            
            if (pmtIn->cbFormat >= sizeof(WAVEFORMATEX)) {
                DbgLog((LOG_TRACE,2,TEXT("cbSize %u"), pwfx->cbSize));
            }
        } else {
        }
        
    } else {
        DbgLog((LOG_TRACE,2,TEXT("     Format type %s"),
            GuidNames[pmtIn->formattype]));
        // !!!! should add code to dump wave format, others
    }
}


void WINAPI DumpGraph(IFilterGraph *pGraph, DWORD dwLevel)
{
    IEnumFilters *pFilters;
    
    DbgLog((LOG_TRACE,dwLevel,TEXT("DumpGraph [%x]"), pGraph));
    
    if (FAILED(pGraph->EnumFilters(&pFilters))) {
        DbgLog((LOG_TRACE,dwLevel,TEXT("EnumFilters failed!")));
    }
    
    IBaseFilter *pFilter;
    ULONG   n;
    while (pFilters->Next(1, &pFilter, &n) == S_OK) {
        FILTER_INFO info;
        
        if (FAILED(pFilter->QueryFilterInfo(&info))) {
            DbgLog((LOG_TRACE,dwLevel,TEXT("    Filter [%x]  -- failed QueryFilterInfo"), pFilter));
        } else {
            QueryFilterInfoReleaseGraph(info);
            
            // !!! should QueryVendorInfo here!
            
            DbgLog((LOG_TRACE,dwLevel,TEXT("    Filter [%x]  '%ls'"), pFilter, info.achName));
            
            IEnumPins *pins;
            
            if (FAILED(pFilter->EnumPins(&pins))) {
                DbgLog((LOG_TRACE,dwLevel,TEXT("EnumPins failed!")));
            } else {
                
                IPin *pPin;
                while (pins->Next(1, &pPin, &n) == S_OK) {
                    PIN_INFO    info;
                    
                    if (FAILED(pPin->QueryPinInfo(&info))) {
                        DbgLog((LOG_TRACE,dwLevel,TEXT("          Pin [%x]  -- failed QueryPinInfo"), pPin));
                    } else {
                        QueryPinInfoReleaseFilter(info);
                        
                        IPin *pPinConnected = NULL;
                        
                        HRESULT hr = pPin->ConnectedTo(&pPinConnected);
                        
                        if (pPinConnected) {
                            DbgLog((LOG_TRACE,dwLevel,TEXT("          Pin [%x]  '%ls' [%sput]")
                                TEXT("  Connected to pin [%x]"),
                                pPin, info.achName,
                                info.dir == PINDIR_INPUT ? TEXT("In") : TEXT("Out"),
                                pPinConnected));
                            
                            pPinConnected->Release();
                            
                            // perhaps we should really dump the type both ways as a sanity
                            // check?
                            if (info.dir == PINDIR_OUTPUT) {
                                AM_MEDIA_TYPE mt;
                                
                                hr = pPin->ConnectionMediaType(&mt);
                                
                                if (SUCCEEDED(hr)) {
                                    DisplayType("Connection type", &mt);
                                    
                                    FreeMediaType(mt);
                                }
                            }
                        } else {
                            DbgLog((LOG_TRACE,dwLevel,
                                TEXT("          Pin [%x]  '%ls' [%sput]"),
                                pPin, info.achName,
                                info.dir == PINDIR_INPUT ? TEXT("In") : TEXT("Out")));
                            
                        }
                    }
                    
                    pPin->Release();
                    
                }
                
                pins->Release();
            }
            
        }
        
        pFilter->Release();
    }
    
    pFilters->Release();
    
}

#endif