diskinfo.cpp

这是DVD中伺服部分的核心代码

/*****************************************************************************
******************************************************************************
**                                                                          **
**  Copyright (c) 2002 Videon Central, Inc.                                 **
**  All rights reserved.                                                    **
**                                                                          **
**  The computer program contained herein contains proprietary information  **
**  which is the property of Videon Central, Inc.  The program may be used  **
**  and/or copied only with the written permission of Videon Central, Inc.  **
**  or in accordance with the terms and conditions stipulated in the        **
**  agreement/contract under which the programs have been supplied.         **
**                                                                          **
******************************************************************************
*****************************************************************************/
/**
 * @file diskinfo.cpp
 *
 * Defines the cDiskInfo class used to examine the disk media for valid disk formats.
 * The main function is getDiskInfo, which processes the disk to determine which media formats are available.
 *
 * $Id: diskinfo.cpp,v 1.31 2007/01/11 19:48:06 jared Exp $
 */

#include "vdvd_types.h"
#include "metanav.h"
#include "diskinfo.h"
#include "dbgprint.h"
#include "../dvd/readdir.h"
#ifdef DMALLOC
#include "dmalloc.h"
#endif

#define SCRATCHSIZE   2560

BYTE bScratchPadBuffer[SCRATCHSIZE];

void operator|=(VDVD_MEDIA_FORMAT &oldformat, VDVD_MEDIA_FORMAT newformat)
{
    oldformat = (VDVD_MEDIA_FORMAT)( oldformat | newformat);
}

cDiskInfo::cDiskInfo()
{
    m_AvailableMediaFormats = MEDIA_FORMAT_UNKNOWN;
}

cDiskInfo::~cDiskInfo()
{
}

/* Examine the disc to determine the type of media available */
void cDiskInfo::readDiskInfo(LOADER_HANDLE tLoader)
{
    BOOLEAN fHDAdvanced;
    BOOLEAN fLoaderReady = FALSE;

    /* determine what type of disc we have */
    if (LoaderGetType(tLoader, &m_LoaderType) != LOADER_SUCCESS)
    {
        m_LoaderType = LOADER_TYPE_UNKNOWN;
    }

    m_AvailableMediaFormats = MEDIA_FORMAT_NODISC;

    /* adjust the loader type and change layer as necessary if the disc is hybrid */
    if (m_LoaderType == LOADER_TYPE_HYBRID)
    {
        LOADER_TYPE ptLayerFormatInformation[LOADER_SUPPORTED_NUMBER_OF_LAYERS] = {LOADER_TYPE_UNKNOWN};
        int layer = 0;

        DbgPrint(("%s(): Detected hybrid disc\n", __FUNCTION__));

        /* grab the layer format type information */
        if (LoaderGetLayerFormatTypeInformation(tLoader, ptLayerFormatInformation) == LOADER_SUCCESS)
        {
            /* check for HD DVD */
            DbgPrint(("%s(): Checking for HD DVD\n", __FUNCTION__));
            for (layer = 0; layer < LOADER_SUPPORTED_NUMBER_OF_LAYERS; layer++)
            {
                if (ptLayerFormatInformation[layer] == LOADER_TYPE_HDDVD)
                {
                    DbgPrint(("%s(): Detected HD DVD on layer %d\n", __FUNCTION__, layer));
                    m_LoaderType = LOADER_TYPE_HDDVD;
                    break;
                }
            }

            /* check for BDROM */
            if (m_LoaderType == LOADER_TYPE_HYBRID)
            {
                DbgPrint(("%s(): Checking for BDROM\n", __FUNCTION__));
                for (layer = 0; layer < LOADER_SUPPORTED_NUMBER_OF_LAYERS; layer++)
                {
                    if (ptLayerFormatInformation[layer] == LOADER_TYPE_BDROM)
                    {
                        DbgPrint(("%s(): Detected BDROM on layer %d\n", __FUNCTION__, layer));
                        m_LoaderType = LOADER_TYPE_BDROM;
                        break;
                    }
                }
            }

            /* check for DVD */
            if (m_LoaderType == LOADER_TYPE_HYBRID)
            {
                DbgPrint(("%s(): Checking for DVD\n", __FUNCTION__));
                for (layer = 0; layer < LOADER_SUPPORTED_NUMBER_OF_LAYERS; layer++)
                {
                    if (ptLayerFormatInformation[layer] == LOADER_TYPE_DVD)
                    {
                        DbgPrint(("%s(): Detected DVD on layer %d\n", __FUNCTION__, layer));
                        m_LoaderType = LOADER_TYPE_DVD;
                        break;
                    }
                }
            }

            /* check for CDROM */
            if (m_LoaderType == LOADER_TYPE_HYBRID)
            {
                DbgPrint(("%s(): Checking for CDROM\n", __FUNCTION__));
                for (layer = 0; layer < LOADER_SUPPORTED_NUMBER_OF_LAYERS; layer++)
                {
                    if (ptLayerFormatInformation[layer] == LOADER_TYPE_CDROM)
                    {
                        DbgPrint(("%s(): Detected CDROM on layer %d\n", __FUNCTION__, layer));
                        m_LoaderType = LOADER_TYPE_CDROM;
                        break;
                    }
                }
            }

            /* adjust the loader type and the layer appropriately */
            if (m_LoaderType == LOADER_TYPE_HYBRID)
            {
                DbgPrint(("%s(): **** ERROR - Unknown format type on all layers of hybrid disc\n", __FUNCTION__));
                m_LoaderType = LOADER_TYPE_UNKNOWN;
            }
            else if (layer > 0)
            {
                /* change to the appropriate layer */
                DbgPrint(("%s(): Changing to layer %d\n", __FUNCTION__, layer));
                if (LoaderChangeLayer(tLoader, layer) != LOADER_SUCCESS)
                {
                    DbgPrint(("%s(): **** ERROR - Change to layer %d failed\n", __FUNCTION__, layer));
                    m_LoaderType = LOADER_TYPE_UNKNOWN;
                }
                else
                {
                    DbgPrint(("%s(): Change to layer %d SUCCESSFUL (m_LoaderType = %d)\n", __FUNCTION__, layer, m_LoaderType));
                }

                /* remount the CDROM device */
                DbgPrint(("%s(): Remounting the CDROM device\n", __FUNCTION__));
                if (LoaderTestUnitReady(tLoader,&fLoaderReady) != LOADER_SUCCESS)
                {
                    DbgPrint(("%s(): **** ERROR - LoaderTestUnitReady() failed\n", __FUNCTION__));
                    m_LoaderType = LOADER_TYPE_UNKNOWN;
                }
                else if (fLoaderReady == FALSE)
                {
                    DbgPrint(("%s(): **** ERROR - Loader is NOT ready\n", __FUNCTION__));
                    m_LoaderType = LOADER_TYPE_UNKNOWN;
                }
            }
        }
    }

    /* analyze to determine what formats are available */
    switch (m_LoaderType)
    {
    case LOADER_TYPE_BDROM:
        if (IsBDROM(tLoader) == TRUE)
        {
            m_AvailableMediaFormats |= MEDIA_FORMAT_BDROM;
        }
        else if (IsHDDVD(tLoader, fHDAdvanced) == TRUE)
        {
            if (fHDAdvanced == TRUE)
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_HDDVD_ADVANCED;
            }
            else
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_HDDVD_STANDARD;
            }
        }
        break;

    case LOADER_TYPE_HDDVD:
        if (IsHDDVD(tLoader, fHDAdvanced) == TRUE)
        {
            if (fHDAdvanced == TRUE)
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_HDDVD_ADVANCED;
            }
            else
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_HDDVD_STANDARD;
            }
        }
        break;

    case LOADER_TYPE_DVD:
        if (IsDVD_V(tLoader) == TRUE)
        {
            m_AvailableMediaFormats |= MEDIA_FORMAT_DVD_V;
        }
        else if (IsDVD_A(tLoader) == TRUE)
        {
            m_AvailableMediaFormats |= MEDIA_FORMAT_DVD_A;
        }
        else if (IsBDROM(tLoader) == TRUE)
        {
            m_AvailableMediaFormats |= MEDIA_FORMAT_BDROM;
        }
        else if (IsHDDVD(tLoader, fHDAdvanced) == TRUE)
        {
            if (fHDAdvanced == TRUE)
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_HDDVD_ADVANCED;
            }
            else
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_HDDVD_STANDARD;
            }
        }
        else if (IsVR(tLoader) == TRUE)
        {
            m_AvailableMediaFormats |= MEDIA_FORMAT_VR;
        }
        break;

    case LOADER_TYPE_CDROM:

        int i;
        ULONG ulStatus;
        BYTE bBuf[4], bDiskType, bControl;

        /* Get Number of Sessions */
        ulStatus = LoaderGetTOC (tLoader, LOADER_TOC_CMD_FULL_TOC, 0, LOADER_TOC_LBN, bBuf, 4);

        /* Grab each session and check its "disk type" variable */
        for (i=0; i<bBuf[3]; i++)
        {
            ulStatus = LoaderGetTOC (tLoader, LOADER_TOC_CMD_FULL_TOC, i, LOADER_TOC_LBN, bScratchPadBuffer, 4 + 11 );

            bControl = bScratchPadBuffer[4+1] & 0x0f;
            bDiskType = bScratchPadBuffer[4 + 9];

            if (IsCDDA(bDiskType, bControl) == TRUE)
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_CDDA;
            }
            if (IsSVCD(tLoader, bDiskType) == TRUE)
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_SVCD;
            }
            if (IsVCD(tLoader, bDiskType) == TRUE)
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_VCD;
            }
            if (IsMP3(tLoader, bDiskType, bControl) == TRUE)
            {
                m_AvailableMediaFormats |= MEDIA_FORMAT_MP3;
            }
        }
        if (m_AvailableMediaFormats == MEDIA_FORMAT_NODISC)
        {
            m_AvailableMediaFormats |= MEDIA_FORMAT_URD;
        }
        break;

    case LOADER_TYPE_NODISK:
        m_AvailableMediaFormats = MEDIA_FORMAT_NODISC;
        break;

    case LOADER_TYPE_UNKNOWN:
        m_AvailableMediaFormats = MEDIA_FORMAT_READ_ERROR;
        break;

    default:
        DbgPrint(("cDiskInfo::readDiskInfo() -- MEDIA_FORMAT_UNKNOWN\n"));
        m_AvailableMediaFormats = MEDIA_FORMAT_UNKNOWN;
        break;
    }

    /*
     * If no available media format was found on the disc, but there is a disc loaded,
     * then the media format is unknown.  This covers the case where there is a known
     * physical disc type but the media format on the disc is not known.
     */
    if ( (m_AvailableMediaFormats == MEDIA_FORMAT_NODISC) && (m_LoaderType != LOADER_TYPE_NODISK) )
    {
        m_AvailableMediaFormats = MEDIA_FORMAT_UNKNOWN;
    }
}

VDVD_MEDIA_FORMAT cDiskInfo::getSupportedMediaFormats(void)
{
    return (m_AvailableMediaFormats);