fakecam.cpp

winddk src目录下的WDM源码压缩!

}

//
// Searches for attachments to an image item
//
HRESULT SearchForAttachments(FAKECAM_DEVICE_INFO *pPrivateDeviceInfo, MCAM_ITEM_INFO *pParent, PTSTR ptszMainItem)
{
    DBG_FN("SearchForAttachments");

    HRESULT hr = S_OK;

    //
    // Locals
    //
    INT iNumAttachments = 0;
    HANDLE hFind = NULL;
    WIN32_FIND_DATA FindData;
    TCHAR tszTempStr[MAX_PATH] = TEXT("");
    TCHAR tszFullName[MAX_PATH] = TEXT("");
    TCHAR *ptcSlash = NULL;
    TCHAR *ptcDot = NULL;
    MCAM_ITEM_INFO *pNonImage = NULL;

    REQUIRE_ARGS(!pPrivateDeviceInfo || !ptszMainItem, hr, "SearchForAttachments");
    
    //
    // Find the last dot in the filename and replace the file extension with * and do the search
    //
    lstrcpyn(tszTempStr, ptszMainItem, sizeof(tszTempStr) / sizeof(tszTempStr[0]) - 1);
    ptcDot = _tcsrchr(tszTempStr, TEXT('.'));
    
    if (ptcDot)
    {
        *(ptcDot+1) = TEXT('*');
        *(ptcDot+2) = TEXT('\0');
    }
    else
    {
        wiauDbgError("SearchForAttachments", "Filename did not contain a dot");
        hr = E_FAIL;
        goto Cleanup;
    }

    //
    // Replace the first four "free" characters of the name with ? (attachments only need to match
    // the last four characters of the name)
    //
    ptcSlash = _tcsrchr(tszTempStr, TEXT('\\'));
    if (ptcSlash && ptcDot - ptcSlash > 4)
    {
        for (INT i = 1; i < 5; i++)
            *(ptcSlash+i) = TEXT('?');
    }

    memset(&FindData, 0, sizeof(FindData));
    hFind = FindFirstFile(tszTempStr, &FindData);
    REQUIRE_FILEHANDLE(hFind, hr, "SearchForAttachments", "FindFirstFile failed");

    while (hr == S_OK)
    {
        if (!(FindData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) &&
            !(_tcsstr(ptszMainItem, FindData.cFileName)))
        {
            //
            // Figure out the full name for the item
            //
            lstrcpyn(tszTempStr, ptszMainItem, sizeof(tszTempStr) / sizeof(tszTempStr[0]));
            ptcSlash = _tcsrchr(tszTempStr, TEXT('\\'));
            if (ptcSlash)
            {
                *ptcSlash = TEXT('\0');
            }

            hr = MakeFullName(tszFullName, sizeof(tszFullName) / sizeof(tszFullName[0]), 
                              tszTempStr, FindData.cFileName);
            REQUIRE_SUCCESS(hr, "SearchForAttachments", "MakeFullName failed");

            hr = CreateNonImage(pPrivateDeviceInfo, pParent, &FindData, &pNonImage, tszFullName);
            REQUIRE_SUCCESS(hr, "SearchForAttachments", "CreateNonImage failed");

            hr = AddItem(pPrivateDeviceInfo, pNonImage);
            REQUIRE_SUCCESS(hr, "SearchForAttachments", "AddItem failed");

            iNumAttachments++;
        }

        memset(&FindData, 0, sizeof(FindData));
        if (!FindNextFile(hFind, &FindData))
        {
            hr = HRESULT_FROM_WIN32(::GetLastError());
            if (hr != HRESULT_FROM_WIN32(ERROR_NO_MORE_FILES))
            {
                wiauDbgErrorHr(hr, "SearchForAttachments", "FindNextFile failed");
                goto Cleanup;
            }
        }
    }
    FindClose(hFind);
    if (iNumAttachments > 0)
        hr = S_OK;
    else
        hr = S_FALSE;

Cleanup:
    return hr;    
}

HRESULT CreateFolder(FAKECAM_DEVICE_INFO *pPrivateDeviceInfo, MCAM_ITEM_INFO *pParent,
                     WIN32_FIND_DATA *pFindData, MCAM_ITEM_INFO **ppFolder, PTSTR ptszFullName)
{
    DBG_FN("CreateFolder");

    HRESULT hr = S_OK;

    //
    // Locals
    //
    TCHAR *ptcDot = NULL;
    MCAM_ITEM_INFO *pItem = NULL;
    TCHAR tszTempStr[MAX_PATH] = TEXT("");

    REQUIRE_ARGS(!pPrivateDeviceInfo || !pFindData || !ppFolder || !ptszFullName, hr, "CreateFolder");
    *ppFolder = NULL;

    pItem = new MCAM_ITEM_INFO;
    REQUIRE_ALLOC(pItem, hr, "CreateFolder");

    //
    // Chop off the filename extension from the name, if it exists
    //
    lstrcpyn(tszTempStr, pFindData->cFileName, sizeof(tszTempStr) / sizeof(tszTempStr[0]));
    ptcDot = _tcsrchr(tszTempStr, TEXT('.'));
    if (ptcDot)
        *ptcDot = TEXT('\0');

    //
    // Fill in the MCAM_ITEM_INFO structure
    //
    hr = SetCommonFields(pItem, tszTempStr, ptszFullName, pFindData);
    REQUIRE_SUCCESS(hr, "CreateFolder", "SetCommonFields failed");
    
    pItem->pParent = pParent;
    pItem->iType = WiaMCamTypeFolder;

    *ppFolder = pItem;

    pPrivateDeviceInfo->iNumItems++;

    wiauDbgTrace("CreateFolder", "Created folder %" WIAU_DEBUG_TSTR " at 0x%08x under 0x%08x", pFindData->cFileName, pItem, pParent);

Cleanup:
    return hr;
}

HRESULT CreateImage(FAKECAM_DEVICE_INFO *pPrivateDeviceInfo, MCAM_ITEM_INFO *pParent,
                    WIN32_FIND_DATA *pFindData, MCAM_ITEM_INFO **ppImage, PTSTR ptszFullName)
{
    DBG_FN("CreateImage");

    HRESULT hr = S_OK;

    //
    // Locals
    //
    PTSTR ptszDot = NULL;
    MCAM_ITEM_INFO *pItem = NULL;
    TCHAR tszTempStr[MAX_PATH] = TEXT("");
    WORD width = 0;
    WORD height = 0;

    REQUIRE_ARGS(!pPrivateDeviceInfo || !pFindData || !ppImage || !ptszFullName, hr, "CreateImage");
    *ppImage = NULL;

    pItem = new MCAM_ITEM_INFO;
    REQUIRE_ALLOC(pItem, hr, "CreateImage");

    //
    // Chop off the filename extension from the name, if it exists
    //
    lstrcpyn(tszTempStr, pFindData->cFileName, sizeof(tszTempStr) / sizeof(tszTempStr[0]));
    ptszDot = _tcsrchr(tszTempStr, TEXT('.'));
    if (ptszDot)
        *ptszDot = TEXT('\0');

    //
    // Fill in the MCAM_ITEM_INFO structure
    //
    hr = SetCommonFields(pItem, tszTempStr, ptszFullName, pFindData);
    REQUIRE_SUCCESS(hr, "CreateImage", "SetCommonFields failed");
    
    pItem->pParent = pParent;
    pItem->iType = WiaMCamTypeImage;
    pItem->pguidFormat = &WiaImgFmt_JPEG;
    pItem->lSize = pFindData->nFileSizeLow;
    pItem->pguidThumbFormat = &WiaImgFmt_JPEG;

    // 
    // Copy the file extension into the extension field
    //
    if (ptszDot) {
        hr = wiauStrT2W(ptszDot + 1, pItem->wszExt, MCAM_EXT_LEN * sizeof(pItem->wszExt[0]));
        REQUIRE_SUCCESS(hr, "CreateImage", "wiauStrT2W failed");
    }

    //
    // Interpret the JPEG image to get the image dimensions and thumbnail size
    //
    hr = ReadDimFromJpeg(ptszFullName, &width, &height);
    REQUIRE_SUCCESS(hr, "CreateImage", "ReadDimFromJpeg failed");

    pItem->lWidth = width;
    pItem->lHeight = height;
    pItem->lDepth = 24;
    pItem->lChannels = 3;
    pItem->lBitsPerChannel = 8;
    
    *ppImage = pItem;

    pPrivateDeviceInfo->iNumItems++;
    pPrivateDeviceInfo->iNumImages++;

    wiauDbgTrace("CreateImage", "Created image %" WIAU_DEBUG_TSTR " at 0x%08x under 0x%08x", pFindData->cFileName, pItem, pParent);

Cleanup:
    return hr;
}

HRESULT CreateNonImage(FAKECAM_DEVICE_INFO *pPrivateDeviceInfo, MCAM_ITEM_INFO *pParent,
                       WIN32_FIND_DATA *pFindData, MCAM_ITEM_INFO **ppNonImage, PTSTR ptszFullName)
{
    DBG_FN("CreateNonImage");

    HRESULT hr = S_OK;

    //
    // Locals
    //
    PTSTR ptszDot = NULL;
    MCAM_ITEM_INFO *pItem = NULL;
    TCHAR tszTempStr[MAX_PATH] = TEXT("");
    PTSTR ptszExt = NULL;

    REQUIRE_ARGS(!pPrivateDeviceInfo || !pFindData || !ppNonImage || !ptszFullName, hr, "CreateNonImage");
    *ppNonImage = NULL;

    pItem = new MCAM_ITEM_INFO;
    REQUIRE_ALLOC(pItem, hr, "CreateNonImage");

    //
    // The name cannot contain a dot and the name needs to be unique
    // wrt the parent image, so replace the dot with an underline character.
    //
    lstrcpyn(tszTempStr, pFindData->cFileName, sizeof(tszTempStr) / sizeof(tszTempStr[0]));
    ptszDot = _tcsrchr(tszTempStr, TEXT('.'));
    if (ptszDot)
        *ptszDot = TEXT('_');

    //
    // Fill in the MCAM_ITEM_INFO structure
    //
    hr = SetCommonFields(pItem, tszTempStr, ptszFullName, pFindData);
    REQUIRE_SUCCESS(hr, "CreateNonImage", "SetCommonFields failed");
    
    pItem->pParent = pParent;
    pItem->iType = WiaMCamTypeOther;
    pItem->lSize = pFindData->nFileSizeLow;

    //
    // Set the format of the item based on the file extension
    //
    if (ptszDot) {
        ptszExt = ptszDot + 1;

        // 
        // Copy the file extension into the extension field
        //
        hr = wiauStrT2W(ptszExt, pItem->wszExt, MCAM_EXT_LEN * sizeof(pItem->wszExt[0]));
        REQUIRE_SUCCESS(hr, "CreateNonImage", "wiauStrT2W failed");

        if (_tcsicmp(ptszExt, TEXT("wav")) == 0) {
            pItem->pguidFormat = &WiaAudFmt_WAV;
            pItem->iType = WiaMCamTypeAudio;
        }
        else if (_tcsicmp(ptszExt, TEXT("mp3")) == 0) {
            pItem->pguidFormat = &WiaAudFmt_MP3;
            pItem->iType = WiaMCamTypeAudio;
        }
        else if (_tcsicmp(ptszExt, TEXT("wma")) == 0) {
            pItem->pguidFormat = &WiaAudFmt_WMA;
            pItem->iType = WiaMCamTypeAudio;
        }
        else if (_tcsicmp(ptszExt, TEXT("rtf")) == 0) {
            pItem->pguidFormat = &WiaImgFmt_RTF;
            pItem->iType = WiaMCamTypeOther;
        }
        else if (_tcsicmp(ptszExt, TEXT("htm")) == 0) {
            pItem->pguidFormat = &WiaImgFmt_HTML;
            pItem->iType = WiaMCamTypeOther;
        }
        else if (_tcsicmp(ptszExt, TEXT("html")) == 0) {
            pItem->pguidFormat = &WiaImgFmt_HTML;
            pItem->iType = WiaMCamTypeOther;
        }
        else if (_tcsicmp(ptszExt, TEXT("txt")) == 0) {
            pItem->pguidFormat = &WiaImgFmt_TXT;
            pItem->iType = WiaMCamTypeOther;
        }
        else if (_tcsicmp(ptszExt, TEXT("mpg")) == 0) {
            pItem->pguidFormat = &WiaImgFmt_MPG;
            pItem->iType = WiaMCamTypeVideo;
        }
        else if (_tcsicmp(ptszExt, TEXT("avi")) == 0) {
            pItem->pguidFormat = &WiaImgFmt_AVI;
            pItem->iType = WiaMCamTypeVideo;
        }
        else if (_tcsicmp(ptszExt, TEXT("asf")) == 0) {
            pItem->pguidFormat = &WiaImgFmt_ASF;
            pItem->iType = WiaMCamTypeVideo;
        }
        else if (_tcsicmp(ptszExt, TEXT("exe")) == 0) {
            pItem->pguidFormat = &WiaImgFmt_EXEC;
            pItem->iType = WiaMCamTypeOther;
        }
        else {
            //
            // Generate a random GUID for the format
            //
            if (g_guidUnknownFormat.Data1 == 0) {
                hr = CoCreateGuid(&g_guidUnknownFormat);
                REQUIRE_SUCCESS(hr, "CreateNonImage", "CoCreateGuid failed");
            }
            pItem->pguidFormat = &g_guidUnknownFormat;
            pItem->iType = WiaMCamTypeOther;
        }
    }

    *ppNonImage = pItem;

    pPrivateDeviceInfo->iNumItems++;

    wiauDbgTrace("CreateNonImage", "Created non-image %" WIAU_DEBUG_TSTR " at 0x%08x under 0x%08x", pFindData->cFileName, pItem, pParent);

Cleanup:
    return hr;
}

//
// Sets the fields of the MCAM_ITEM_INFO that are common to all items
//
HRESULT SetCommonFields(MCAM_ITEM_INFO *pItem,
                        PTSTR ptszShortName,
                        PTSTR ptszFullName,
                        WIN32_FIND_DATA *pFindData)
{
    DBG_FN("SetCommonFields");

    HRESULT hr = S_OK;
    BOOL ret;

    //
    // Locals
    //
    PTSTR ptszTempStr = NULL;
    INT iSize = 0;

    REQUIRE_ARGS(!pItem || !ptszShortName || !ptszFullName || !pFindData, hr, "SetFullName");

    //
    // Initialize the structure
    //
    memset(pItem, 0, sizeof(MCAM_ITEM_INFO));
    pItem->iSize = sizeof(MCAM_ITEM_INFO);
    
    iSize = lstrlen(ptszShortName) + 1;
    pItem->pwszName = new WCHAR[iSize];
    REQUIRE_ALLOC(pItem->pwszName, hr, "SetCommonFields");
    wiauStrT2W(ptszShortName, pItem->pwszName, iSize * sizeof(WCHAR));
    REQUIRE_SUCCESS(hr, "SetCommonFields", "wiauStrT2W failed");

    FILETIME ftLocalFileTime;
    memset(&pItem->Time, 0, sizeof(pItem->Time));
    memset(&ftLocalFileTime, 0, sizeof(FILETIME));
    ret = FileTimeToLocalFileTime(&pFindData->ftLastWriteTime, &ftLocalFileTime);
    REQUIRE_FILEIO(ret, hr, "SetCommonFields", "FileTimeToLocalFileTime failed");
    ret = FileTimeToSystemTime(&ftLocalFileTime, &pItem->Time);
    REQUIRE_FILEIO(ret, hr, "SetCommonFields", "FileTimeToSystemTime failed");

    pItem->bReadOnly = pFindData->dwFileAttributes & FILE_ATTRIBUTE_READONLY;
    pItem->bCanSetReadOnly = TRUE;

    //
    // Set the private storage area of the MCAM_ITEM_INFO structure to the
    // full path name of the item
    //
    iSize = lstrlen(ptszFullName) + 1;
    ptszTempStr = new TCHAR[iSize];
    REQUIRE_ALLOC(ptszTempStr, hr, "SetCommonFields");
    lstrcpy(ptszTempStr, ptszFullName);
    pItem->pPrivateStorage = (BYTE *) ptszTempStr;

Cleanup:
    return hr;
}

HRESULT AddItem(FAKECAM_DEVICE_INFO *pPrivateDeviceInfo, MCAM_ITEM_INFO *pItem)
{
    HRESULT hr = S_OK;

    REQUIRE_ARGS(!pPrivateDeviceInfo || !pItem, hr, "AddItem");

    if (pPrivateDeviceInfo->pLastItem) {
        //
        // Insert the item at the end of the list
        //
        pPrivateDeviceInfo->pLastItem->pNext = pItem;
        pItem->pPrev = pPrivateDeviceInfo->pLastItem;
        pItem->pNext = NULL;
        pPrivateDeviceInfo->pLastItem = pItem;
    }
    else
    {
        //
        // List is currently empty, add this as first and only item
        //
        pPrivateDeviceInfo->pFirstItem = pPrivateDeviceInfo->pLastItem = pItem;
        pItem->pPrev = pItem->pNext = NULL;
    }

Cleanup:
    return hr;
}

HRESULT RemoveItem(FAKECAM_DEVICE_INFO *pPrivateDeviceInfo, MCAM_ITEM_INFO *pItem)
{
    HRESULT hr = S_OK;

    REQUIRE_ARGS(!pPrivateDeviceInfo || !pItem, hr, "RemoveItem");

    if (pItem->pPrev)
        pItem->pPrev->pNext = pItem->pNext;
    if (pItem->pNext)
        pItem->pNext->pPrev = pItem->pPrev;

    if (pPrivateDeviceInfo->pFirstItem == pItem)
        pPrivateDeviceInfo->pFirstItem = pItem->pNext;
    if (pPrivateDeviceInfo->pLastItem == pItem)
        pPrivateDeviceInfo->pLastItem = pItem->pPrev;

Cleanup:
    return hr;
}