//-------------------------------------------------------------------------
//
//  Copyright (c) 1999  Microsoft Corporation.
//
//  camopen.cpp
//
//  Abstract:
//
//     Enumerate disk images to emulate camera
//
//  Author:
//
//     Edward Reus    27/Jul/99
//     modeled after code by Mark Enstrom
//
//-------------------------------------------------------------------------

#include <windows.h>
#include <stdio.h>
#include <objbase.h>
#include <tchar.h>

#include "sti.h"
#include "ircamera.h"
#include <irthread.h>

extern HINSTANCE g_hInst; // Global hInstance

#define  __GLOBALPROPVARS__

#include "resource.h"
#include "defprop.h"

//-------------------------------------------------------------------------
//  IrUsdDevice::CamOpenCamera()
//
//   Initialize the IrTran-P camera driver.
//
//   This is a helper called by IrUsdDevice::Initialize().
//
// Arguments:
//
//   pGenericStatus    -    camera status
//
// Return Value:
//
//   HRESULT - S_OK
//
//-------------------------------------------------------------------------
HRESULT IrUsdDevice::CamOpenCamera( IN OUT CAMERA_STATUS *pCameraStatus )
    {
    HRESULT    hr = S_OK;
    SYSTEMTIME SystemTime;

    WIAS_TRACE((g_hInst,"IrUsdDevice::CamOpenCamerai()"));

    //
    // Initialize camera state:
    //
    memset( pCameraStatus, 0, sizeof(CAMERA_STATUS) );

    pCameraStatus->FirmwareVersion = 0x00000001;
    pCameraStatus->NumPictTaken = 20;
    pCameraStatus->NumPictRemaining = 0;
    pCameraStatus->ThumbWidth = 80;
    pCameraStatus->ThumbHeight= 60;
    pCameraStatus->PictWidth  = 300;
    pCameraStatus->PictHeight = 300;

    GetSystemTime( &(pCameraStatus->CameraTime) );

    return hr;
    }


//-------------------------------------------------------------------------
// IrUsdDevice::CamBuildImageTree()
//
//    Build the tree of camera images by enumerating a disk directory for
//    all .JPG files.
//
// Arguments:
//
//    pCamStatus  -    device status
//    ppRootFile  -    return new root of item tree
//
// Return Value:
//
//    status
//
//-------------------------------------------------------------------------
HRESULT IrUsdDevice::CamBuildImageTree( OUT CAMERA_STATUS  *pCamStatus,
                                        OUT IWiaDrvItem   **ppRootFile )
    {
    HRESULT  hr = S_OK;

    WIAS_TRACE((g_hInst,"IrUsdDevice::CamBuildImageTree()"));

    //
    // Create the new image root:
    //
    BSTR bstrRoot = SysAllocString(L"Root");

    if (!bstrRoot)
        {
        return E_OUTOFMEMORY;
        }

    //
    // Call Wia service library to create new root item:
    //
    hr = wiasCreateDrvItem( WiaItemTypeFolder | WiaItemTypeRoot | WiaItemTypeDevice,
                            bstrRoot,
                            m_bstrRootFullItemName,
                            (IWiaMiniDrv*)this,
                            sizeof(IRCAM_IMAGE_CONTEXT),
                            NULL,
                            ppRootFile );

    SysFreeString(bstrRoot);

    if (FAILED(hr))
        {
        WIAS_ERROR((g_hInst,"ddevBuildDeviceItemTree, CreateDeviceItem failed"));
        return hr;
        }

    //
    // Enumerate the root directory:
    //
    CHAR  *pszImageDirectory = GetImageDirectory();

    if (!pszImageDirectory)
        {
        return E_OUTOFMEMORY;
        }

    #ifdef UNICODE

    WCHAR  wszPath[MAX_PATH];

    mbstowcs( wszPath, pszImageDirectory, strlen(pszImageDirectory) );

    hr = EnumDiskImages( *ppRootFile, wszPath );

    #else

    hr = EnumDiskImages( *ppRootFile, pszImageDirectory );

    #endif


    // Don't free pszImageDirectory!!

    return (hr);
    }

//-------------------------------------------------------------------------
// IrUsdDevice::EnumDiskImages()
//
//   Walk through camera temp directory looking for JPEG files to pick up.
//
// Arguments:
//
//   pRootFile
//   pwszDirName
//
// Return Value:
//
//   status
//
//-------------------------------------------------------------------------
HRESULT IrUsdDevice::EnumDiskImages( IWiaDrvItem *pRootFile,
                                     TCHAR       *pszDirName )
    {
    HRESULT          hr = E_FAIL;
    WIN32_FIND_DATA  FindData;
    TCHAR           *pTempName;

    WIAS_TRACE((g_hInst,"IrUsdDevice::EnumDiskImages()"));

    pTempName = (TCHAR*)ALLOC(MAX_PATH);
    if (!pTempName)
        {
        return E_OUTOFMEMORY;
        }

    _tcscpy( pTempName, pszDirName);
    _tcscat( pTempName, TEXT("\\*.jpg") );

    //
    // Look for files at the specified directory:
    //
    HANDLE hFile = FindFirstFile( pTempName, &FindData );

    if (hFile != INVALID_HANDLE_VALUE)
        {
        BOOL bStatus;

        do {
            //
            // Add an image to this folder.
            //
            // Create file name:
            //

            _tcscpy(pTempName, pszDirName);
            _tcscat(pTempName, TEXT("\\"));
            _tcscat(pTempName, FindData.cFileName);

            //
            // Create a new DrvItem for this image and add it to the
            // DrvItem tree.
            //

            IWiaDrvItem *pNewImage;

            hr = CreateItemFromFileName(
                         WiaItemTypeFile | WiaItemTypeImage,
                         pTempName,
                         FindData.cFileName,
                         &pNewImage);

            if (FAILED(hr))
                {
                break;
                }

            hr = pNewImage->AddItemToFolder(pRootFile);

            pNewImage->Release();

            //
            // Look for the next image:
            //
            bStatus = FindNextFile(hFile,&FindData);

        } while (bStatus);

        FindClose(hFile);
    }

    //
    // Now look for directories,
    // add a new PCAMERA_FILE for each sub directory found
    //

    _tcscpy(pTempName, pszDirName);
    _tcscat(pTempName, TEXT("\\*.*"));

    hFile = FindFirstFile( pTempName,&FindData );

    if (hFile != INVALID_HANDLE_VALUE)
        {
        BOOL bStatus;

        do {
            if (  (FindData.cFileName[0] != L'.')
               && (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
                {
                //
                // Found a subdirectory:
                //

                _tcscpy(pTempName, pszDirName);
                _tcscat(pTempName, TEXT("\\"));
                _tcscat(pTempName, FindData.cFileName);

                //
                // Create a new folder for the sub-directory:
                //

                IWiaDrvItem *pNewFolder;

                hr = CreateItemFromFileName(
                                 WiaItemTypeFolder,
                                 pTempName,
                                 FindData.cFileName,
                                 &pNewFolder);

                if (FAILED(hr))
                    {
                    continue;
                    }

                hr = pNewFolder->AddItemToFolder(pRootFile);

                pNewFolder->Release();

                if (hr == S_OK)
                    {
                    //
                    // Enumerate the sub-folder
                    //
                    EnumDiskImages(pNewFolder, pTempName);
                    }
                }

            bStatus = FindNextFile(hFile,&FindData);

        } while (bStatus);

        FindClose(hFile);
        }

    FREE(pTempName);

    return S_OK;
    }

//-------------------------------------------------------------------------
// IrUsdDevice::CreateItemFromFileName()
//
//    Helper funtion used by EnumDiskImages to create dev items and names.
//
// Arguments:
//
//    FolderType  - type of item to create
//    pszPath     - complete path name
//    pszName     - file name
//    ppNewFolder - return new item
//
// Return Value:
//
//   status
//
//-------------------------------------------------------------------------
HRESULT IrUsdDevice::CreateItemFromFileName( LONG          FolderType,
                                             TCHAR        *pszPath,
                                             TCHAR        *pszName,
                                             IWiaDrvItem **ppNewFolder )
    {
    HRESULT  hr = S_OK;
    WCHAR    wszFullItemName[MAX_PATH];
    WCHAR    wszTemp[MAX_PATH];
    BSTR     bstrItemName;
    BSTR     bstrFullItemName;
    IWiaDrvItem  *pNewFolder = 0;

    WIAS_TRACE((g_hInst,"IrUsdDevice::CreateItemFromFileName()"));

    *ppNewFolder = NULL;

    //
    // Convert path to wide char
    //
    CHAR *pszImageDirectory = ::GetImageDirectory();

    if (!pszImageDirectory)
        {
        return E_OUTOFMEMORY;
        }

    DWORD dwImageDirectoryLen = strlen(pszImageDirectory);

    #ifndef UNICODE
    MultiByteToWideChar( CP_ACP,
                         0,
                         pszPath + dwImageDirectoryLen,
                         strlen(pszPath) - dwImageDirectoryLen - 4,
                         wszTemp,
                         MAX_PATH);
    #else
    wcscpy(wszTemp, pszPath+dwImageDirectoryLen);
    #endif

    if (FolderType & ~WiaItemTypeFolder)
        {
        wszTemp[_tcslen(pszPath) - strlen(pszImageDirectory) - 4] = 0;
        }

    wcscpy(wszFullItemName, m_bstrRootFullItemName);
    wcscat(wszFullItemName, wszTemp);

    //
    // Convert item name to wide char:
    //

    #ifndef UNICODE
    MultiByteToWideChar( CP_ACP,
                         0,
                         pszName,
                         strlen(pszName)-4,
                         wszTemp,
                         MAX_PATH);
    #else
    wcscpy(wszTemp, pszName);
    #endif

    if (FolderType & ~WiaItemTypeFolder)
        {
        wszTemp[_tcslen(pszName)-4] = 0;
        }

    bstrItemName = SysAllocString(wszTemp);

    if (bstrItemName)
        {
        bstrFullItemName = SysAllocString(wszFullItemName);

        if (bstrFullItemName)
            {
            //
            // Call WIA to create new DrvItem
            //

            IRCAM_IMAGE_CONTEXT *pContext = 0;

            hr = wiasCreateDrvItem( FolderType,
                                    bstrItemName,
                                    bstrFullItemName,
                                    (IWiaMiniDrv *)this,
                                    sizeof(IRCAM_IMAGE_CONTEXT),
                                    (BYTE **)&pContext,
                                    &pNewFolder);

            if (hr == S_OK)
                {
                //
                // init device specific context (image path)
                //
                pContext->pszCameraImagePath = _tcsdup(pszPath);
                }
            else
                {
                WIAS_ERROR((g_hInst,"ddevBuildDeviceItemTree, wiasCreateDrvItem failed"));
                }

            SysFreeString(bstrFullItemName);
            }
        else
            {
            WIAS_ERROR((g_hInst,"ddevBuildDeviceItemTree, unable to allocate full item name"));
            hr = E_OUTOFMEMORY;
            }

        SysFreeString(bstrItemName);
        }
    else
        {
        WIAS_ERROR((g_hInst,"ddevBuildDeviceItemTree, unable to allocate item name"));
        hr = E_OUTOFMEMORY;
        }

    //
    // Assign output value and cleanup
    //

    if (hr == S_OK)
        {
        *ppNewFolder = pNewFolder;
        }
    else
        {
        //
        // delete item
        //
        }

    return hr;
}

//-------------------------------------------------------------------------
// SetItemSize()
//
//   Helper function to call wias to calc new item size
//
// Arguments:
//
//   pWiasContext       - item
//
// Return Value:
//
//    Status
//
//-------------------------------------------------------------------------
HRESULT SetItemSize( BYTE* pWiasContext )
    {
    HRESULT                    hr;
    MINIDRV_TRANSFER_CONTEXT   drvTranCtx;

    memset( &drvTranCtx, 0, sizeof(MINIDRV_TRANSFER_CONTEXT) );

    hr = wiasReadPropGuid( pWiasContext,
                           WIA_IPA_FORMAT,
                           (GUID*)&drvTranCtx.guidFormatID,
                           NULL,
                           false );
    if (FAILED(hr))
        {
        return hr;
        }

    hr = wiasReadPropLong( pWiasContext,
                           WIA_IPA_TYMED,
                           (LONG*)&drvTranCtx.tymed,
                           NULL,
                           false );
    if (FAILED(hr))
        {
        return hr;
        }

    WIAS_TRACE((g_hInst,"SetItemSize(): tymed: %d",drvTranCtx.tymed));

    //
    // wias works for DIB and TIFF formats.
    //
    // Driver doesn't support JPEG
    //

    hr = wiasGetImageInformation(pWiasContext,
                                 WIAS_INIT_CONTEXT,
                                 &drvTranCtx);

    if (hr == S_OK)
        {
        WIAS_TRACE((g_hInst,"SetItemSize(): lItemSize: %d",drvTranCtx.lItemSize));
        hr = wiasWritePropLong(pWiasContext, WIA_IPA_ITEM_SIZE, drvTranCtx.lItemSize);
        hr = wiasWritePropLong(pWiasContext, WIA_IPA_BYTES_PER_LINE, drvTranCtx.cbWidthInBytes);
        }

    return hr;
    }

//-------------------------------------------------------------------------
// IrUsdDevice::InitImageInformation()
//
//    Init image properties
//
// Arguments:
//
//
// Return Value:
//
//    Status
//
//-------------------------------------------------------------------------
HRESULT IrUsdDevice::InitImageInformation( BYTE                *pWiasContext,
                                           IRCAM_IMAGE_CONTEXT *pContext,
                                           LONG                *plDevErrVal)
    {
    int                      i;
    HRESULT                  hr = S_OK;
    CAMERA_PICTURE_INFO      camInfo;
    PROPVARIANT              propVar;

    WIAS_TRACE((g_hInst,"IrUsdDevice::InitImageInformation()"));

    //
    // GET image info
    //

    hr = CamGetPictureInfo( pContext,
                            &camInfo );

    if (hr != S_OK)
        {
        return hr;
        }

    //
    // Use WIA services to write image properties:
    //
    wiasWritePropLong( pWiasContext,
                       WIA_IPC_THUMB_WIDTH,
                       camInfo.ThumbWidth);

    wiasWritePropLong( pWiasContext,
                       WIA_IPC_THUMB_HEIGHT,
                       camInfo.ThumbHeight );

    wiasWritePropLong( pWiasContext,
                       WIA_IPA_PIXELS_PER_LINE,
                       camInfo.PictWidth );

    wiasWritePropLong( pWiasContext,
                       WIA_IPA_NUMBER_OF_LINES,
                       camInfo.PictHeight );

    wiasWritePropGuid( pWiasContext,
                       WIA_IPA_PREFERRED_FORMAT,
                       WiaImgFmt_JPEG );

    wiasWritePropLong( pWiasContext,
                       WIA_IPA_DEPTH,
                       camInfo.PictBitsPerPixel );

    wiasWritePropBin( pWiasContext,
                      WIA_IPA_ITEM_TIME,
                      sizeof(SYSTEMTIME),
                      (PBYTE)&camInfo.TimeStamp );

    wiasWritePropLong( pWiasContext,
                       WIA_IPA_DATATYPE,
                       WIA_DATA_COLOR );

    wiasWritePropLong( pWiasContext,
                       WIA_IPA_ITEM_SIZE,
                       camInfo.PictCompSize );

    wiasWritePropLong( pWiasContext,
                       WIA_IPA_BYTES_PER_LINE,
                       camInfo.PictBytesPerRow );

    //
    // Calculate item size
    //
    // hr = SetItemSize(pWiasContext); BUGBUG

    //
    // Load a thumbnail of the image:
    //
    PBYTE pThumb;
    LONG  lSize;

    hr = CamLoadThumbnail(pContext, &pThumb, &lSize);

    if (hr == S_OK)
        {
        //
        // write thumb property
        //
        PROPSPEC    propSpec;
        PROPVARIANT propVar;

        propVar.vt          = VT_VECTOR | VT_UI1;
        propVar.caub.cElems = lSize;
        propVar.caub.pElems = pThumb;

        propSpec.ulKind = PRSPEC_PROPID;
        propSpec.propid = WIA_IPC_THUMBNAIL;

        hr = wiasWriteMultiple(pWiasContext, 1, &propSpec, &propVar);

        FREE(pThumb);
        }

    //
    // Use WIA services to set the extended property access and
    // valid value information from gWiaPropInfoDefaults.
    //

    hr =  wiasSetItemPropAttribs(pWiasContext,
                                 NUM_CAM_ITEM_PROPS,
                                 gPropSpecDefaults,
                                 gWiaPropInfoDefaults);
    return hr;
    }