metanav.cpp

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

    /* record autoplay state */
    m_fAutoPlay = fAutoPlay;

    /* kick off the disc type detection */
    pMessage = (MESSAGE *)m_pDiscQueue->GetMsg(OS_WAIT_FOREVER);
    if (NULL != pMessage)
    {
        pMessage->ulMsgType = DISCMSG_DETECT_MEDIA_TYPE;
        m_pDiscQueue->Write(pMessage);
    }

    return (METANAV_SUCCESS);
}

/**
 * Private function used to detect the media format and start playback if
 * AutoPlay is enabled. This function is used by the DiscTask only!
 *
 * @return
 *      METANAV_SUCCESS if successful
 *      METANAV_FAILURE if unsuccessful
 */
METANAV_STATUS cMetaNav::DetectMediaType(void)
{
    VDVD_MEDIA_FORMAT format = MEDIA_FORMAT_UNKNOWN;
    METANAV_STATUS    status = METANAV_SUCCESS;
    ULONG             out_msg[4];

    /* get the disc info */
    m_pDiskInfo->readDiskInfo(m_Loader);

    /* get the available formats found */
    format = m_pDiskInfo->getSupportedMediaFormats();

    /* Send a no disc message if necessary */
    if (format == MEDIA_FORMAT_NODISC)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::DetectMediaType() -- MEDIA_FORMAT_NODISC\n"));

        /* Send response of the type of disc */
        out_msg[0] = VDVD_STATUS_NO_DISC;
        if (UsrEventHandler(out_msg) != USR_SUCCESS)
        {
            DbgPrint(("cMetaNav::DetectMediaType -- Unable to send response\n"));
            status = METANAV_FAILURE;
        }
        return (status);
    }

    /* Send an unknown format message if necessary */
    if (format == MEDIA_FORMAT_UNKNOWN)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::DetectMediaType() -- MEDIA_FORMAT_UNKNOWN\n"));

        /* Send response of the type of disc */
        out_msg[0] = VDVD_STATUS_DISC_TYPE;
        out_msg[1] = MEDIA_FORMAT_UNKNOWN;
        if (UsrEventHandler(out_msg) != USR_SUCCESS)
        {
            DbgPrint(("cMetaNav::DetectMediaType -- Unable to send response\n"));
            status = METANAV_FAILURE;
        }
        return (status);
    }

    /* Send a read error event if necessary */
    if (format == MEDIA_FORMAT_READ_ERROR)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::DetectMediaType() -- MEDIA_FORMAT_READ_ERROR\n"));

        /* Send response of the type of disc */
        out_msg[0] = VDVD_STATUS_DISC_TYPE;
        out_msg[1] = MEDIA_FORMAT_READ_ERROR;
        if (UsrEventHandler(out_msg) != USR_SUCCESS)
        {
            DbgPrint(("cMetaNav::DetectMediaType -- Unable to send response\n"));
            status = METANAV_FAILURE;
        }
        return (status);
    }

    /* If autoplay is set, pick the preferred nav type from the available formats */
    if (m_fAutoPlay == TRUE)
    {
        if (format & MEDIA_FORMAT_HDDVD_STANDARD)
        {
            /* Start hd-dvd nav for standard content */
            format = MEDIA_FORMAT_HDDVD_STANDARD;
        }
        else if (format & MEDIA_FORMAT_HDDVD_ADVANCED)
        {
            /* Start the hd-dvd nav for advanced content */
            format = MEDIA_FORMAT_HDDVD_ADVANCED;
        }
        else if (format & MEDIA_FORMAT_BDROM)
        {
            /* Start the BDROM nav */
            format = MEDIA_FORMAT_BDROM;
        }
        else if (format & MEDIA_FORMAT_DVD_V)
        {
            /* Start the dvd video nav */
            format = MEDIA_FORMAT_DVD_V;
        }
        else if (format & MEDIA_FORMAT_DVD_A)
        {
            /* Start the dvd audio nav */
            format = MEDIA_FORMAT_DVD_A;
        }
        else if (format & MEDIA_FORMAT_SVCD)
        {
            /* Start the svcd nav (vcd nav) */
            format = MEDIA_FORMAT_SVCD;
        }
        else if (format & MEDIA_FORMAT_VCD)
        {
            /* Start the vcd nav */
            format = MEDIA_FORMAT_VCD;
        }
        else if (format & MEDIA_FORMAT_MP3)
        {
            /* Start the urd nav */
            format = MEDIA_FORMAT_MP3;
        }
        else if (format & MEDIA_FORMAT_URD)
        {
            /* Start the urd nav */
            format = MEDIA_FORMAT_URD;
        }
        else if (format & MEDIA_FORMAT_CDDA)
        {
            /* Start the cdda nav */
            format = MEDIA_FORMAT_CDDA;
        }
        else if (format & MEDIA_FORMAT_VR)
        {
            /* Start the vr nav */
            format = MEDIA_FORMAT_VR;
        }
        else
        {
            DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::DetectMediaType() -- METANAV_INVALID_MEDIA_FORMAT\n"));

            /* This is an error. An invalid media format is specified */
            /* Send response of the type of disc */
            out_msg[0] = VDVD_STATUS_DISC_TYPE;
            out_msg[1] = MEDIA_FORMAT_UNKNOWN;
            if (UsrEventHandler(out_msg) != USR_SUCCESS)
            {
                DbgPrint(("cMetaNav::DetectMediaType() -- Unable to send response\n"));
            }

            return (METANAV_INVALID_MEDIA_FORMAT);
        }

        /* start the media specific nav */
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::DetectMediaType() -- StartNav\n"));
        status = StartNav(format);
    }
    else
    {
        /* Send response of the type of disc */
        out_msg[0] = VDVD_STATUS_DISC_TYPE;
        out_msg[1] = format;
        if (UsrEventHandler(out_msg) != USR_SUCCESS)
        {
            DbgPrint(("cMetaNav::DetectMediaType() -- Unable to send response\n"));
            status = METANAV_FAILURE;
        }
    }

    return (status);
}

/**
 * Launches the media specific navigator specified by the given media format.
 *
 * @param mediaFormat - Specifes the desired media format to play. This determines
 *                      which media specific navigator will be launched.
 *
 * @return
 *      METANAV_SUCCESS if successful
 *      METANAV_FAILURE if unsuccessful
 */
METANAV_STATUS cMetaNav::StartNav(VDVD_MEDIA_FORMAT mediaFormat)
{
    METANAV_STATUS status = METANAV_FAILURE;
    ULONG          out_msg[4];

    DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StartNav() -- ENTER\n"));

    /*
     * If standby command is currently processing, then do not start nav, because
     * it will just be stopped again once command is fully processed.
     */
#ifdef STANDBY_SUPPORT
    if (m_fStandbyProcessing)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StartNav() -- Do not start nav, waiting for standby\n"));
        m_MediaFormat = MEDIA_FORMAT_UNKNOWN;
        return (METANAV_SUCCESS);
    }
#endif

    /* make sure the nav is not already started */
    if (m_MediaFormat != MEDIA_FORMAT_UNKNOWN)
    {
        return (METANAV_INVALID_STATE);
    }

    /* Send response that the disc read is complete */
    out_msg[0] = VDVD_STATUS_LOAD_COMPLETE;
    out_msg[1] = VDVD_LOADING_DISC;
    UsrEventHandler(out_msg);

    /* Send response of the type of disc */
    out_msg[0] = VDVD_STATUS_DISC_TYPE;
    out_msg[1] = (ULONG)mediaFormat;
    if (UsrEventHandler(out_msg) != USR_SUCCESS)
    {
        DbgPrint(("cMetaNav::StartNav -- Unable to send response\n"));
    }

    if (NULL != m_pDiskInfo)
    {
        if ( (m_pDiskInfo->getSupportedMediaFormats() & mediaFormat) != 0)
        {
            /* For disks that have no APS/CGMS.
             * Call PEiConfigureSetCGMS() to initialize line 20, to set
             * WSS/CGMS/APS to the default values
             */
            PEiConfigureSetVideoMacrovision(m_PE, 0);
            PEiConfigureSetCGMS(m_PE, 0);    /* disable CGMS on the output */

#ifdef BDROM_ENABLE
            /* if the new media format is NOT BDROM and a BD-J app is unbound
             * then kill it now */
            if ( (mediaFormat != MEDIA_FORMAT_BDROM) && (m_fIsDiscUnbound == TRUE) )
            {
                /* kill the unbound BD-J app */
                m_fIsDiscUnbound = FALSE;
                StopBDROMNav();
            }
#endif

            switch (mediaFormat)
            {
#ifdef MP3_ENABLE
            case MEDIA_FORMAT_URD:
            case MEDIA_FORMAT_MP3:
                status = StartMP3Nav();
                break;
#endif

#ifdef VCD_ENABLE
            case MEDIA_FORMAT_VCD:
                status = StartVCDNav(STREAM_TYPE_MPEG1_SS);
                break;
           case MEDIA_FORMAT_SVCD:
                status = StartVCDNav(STREAM_TYPE_MPEG2_PS);
                break;
#endif

#ifdef HDDVD_ENABLE
            case MEDIA_FORMAT_HDDVD_STANDARD:
                status = StartHDDVDNavStd();
                break;
            case MEDIA_FORMAT_HDDVD_ADVANCED:
                status = StartHDDVDNavAdv();
                break;
#endif

            case MEDIA_FORMAT_DVD_V:
            case MEDIA_FORMAT_DVD_A:
                DBGPRINT(DBG_ON(DBG_TRACE), ("%s(%d): StartDVDNav\n", __FILE__, __LINE__));
                status = StartDVDNav();
                break;

#ifdef CDDA_ENABLE
            case MEDIA_FORMAT_CDDA:
                status = StartCDDANav();
                if ( METANAV_SUCCESS != status )
                {
                    StopCDDANav();
                }
                break;
#endif

#ifdef BDROM_ENABLE
            case MEDIA_FORMAT_BDROM:

                /* Notify UI that we are loading a blu-ray title */
                out_msg[0] = VDVD_STATUS_LOADING;
                out_msg[1] = VDVD_LOADING_TITLE;
                UsrEventHandler(out_msg);

                status = StartBDROMNav();
                m_fIsDiscUnbound = FALSE;
                break;
#endif

#ifdef VR_ENABLE
            case MEDIA_FORMAT_VR:
                status = StartVRNav();
                break;
#endif

            case MEDIA_FORMAT_UNKNOWN:
            default:
                break;
            }
        }
    }

    if (METANAV_SUCCESS != status)
    {
        m_MediaFormat = MEDIA_FORMAT_UNKNOWN;

        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StartNav() -- NAV start failed, set MEDIA_FORMAT_UNKNOWN\n"));

        /* There was an error loading the navigator, so send notification */
        out_msg[0] = VDVD_STATUS_DISC_TYPE;
        out_msg[1] = MEDIA_FORMAT_READ_ERROR;
        if (UsrEventHandler(out_msg) != USR_SUCCESS)
        {
            DbgPrint(("cMetaNav::StartNav() -- Unable to send response\n"));
            status = METANAV_FAILURE;
        }
    }
    else
    {
        m_MediaFormat = mediaFormat;
    }

    return (status);
}

/**
 * Stops the currently active media specific navigator.
 *
 * @return
 *      METANAV_SUCCESS if successful
 *      METANAV_FAILURE if unsuccessful
 */
METANAV_STATUS cMetaNav::StopNav(void)
{
	METANAV_STATUS tStatus = METANAV_SUCCESS;
    VDVD_MEDIA_FORMAT media_format = m_MediaFormat;

	/* Take the stop nav semaphore */
	if (OS_OK != OS_SemTake(m_semStopNav, OS_WAIT_FOREVER))
	{
		DBGPRINT(DBG_ON(DBG_ERROR), ("cMetaNav::StopNav -- could not TAKE stop nav semaphore\n"));
		tStatus = METANAV_FAILURE;
	}

    /* reset the media format to unknown */
    m_MediaFormat = MEDIA_FORMAT_UNKNOWN;

    /* For disks that have no APS/CGMS.
     * Call PEiConfigureSetCGMS() to initialize line 20, to set
     * WSS/CGMS/APS to the default values
     */
    PEiConfigureSetVideoMacrovision(m_PE, 0);
    PEiConfigureSetCGMS(m_PE, 0);    /* disable CGMS on the output */

    /* stop the current media specific nav */
    switch (media_format)
    {
#ifdef MP3_ENABLE
    case MEDIA_FORMAT_URD:
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stop the mp3 Nav\n"));
        StopMP3Nav();
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stopped the nav successfully\n"));
        break;
#endif

#ifdef VCD_ENABLE
    case MEDIA_FORMAT_VCD:
    case MEDIA_FORMAT_SVCD:
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stop the vcd Nav\n"));
        StopVCDNav();
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stopped the nav successfully\n"));
        break;
#endif

    case MEDIA_FORMAT_DVD_A:
    case MEDIA_FORMAT_DVD_V:
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stop the dvd Nav\n"));
        StopDVDNav();
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stopped the nav successfully\n"));
        break;

#ifdef VR_ENABLE
    case MEDIA_FORMAT_VR:
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stop the dvd-vr Nav\n"));
        StopVRNav();
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stopped the nav successfully\n"));
        break;
#endif

#ifdef BDROM_ENABLE
    case MEDIA_FORMAT_BDROM:
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stop the BDROM Nav\n"));
        if (BDROMAppDiscEject(&m_fIsDiscUnbound) != BDAPP_SUCCESS)
        {
            /* in case of error default to terminating the BDROM nav */
            m_fIsDiscUnbound = FALSE;
        }
        StopBDROMNav();
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stopped the nav successfully\n"));
        break;
#endif

#ifdef CDDA_ENABLE
    case MEDIA_FORMAT_CDDA:
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stop the cdda Nav\n"));
        StopCDDANav();
        DBGPRINT(DBG_ON(DBG_TRACE), ("cMetaNav::StopNav -- stopped the nav successfully\n"));
        break;
#endif

#ifdef HDDVD_ENABLE
    case MEDIA_FORMAT_HDDVD_STANDARD:
        StopHDDVDNavStd();
        break;

    case MEDIA_FORMAT_HDDVD_ADVANCED:
        StopHDDVDNavAdv();
        break;
#endif

    case MEDIA_FORMAT_NODISC:
    case MEDIA_FORMAT_UNKNOWN:
    default:
        break;
    }

	/* Give the stop nav semaphore */
	if (OS_OK != OS_SemGive(m_semStopNav))
	{
		DBGPRINT(DBG_ON(DBG_ERROR), ("cMetaNav::StopNav -- could not GIVE stop nav semaphore\n"));
		tStatus = METANAV_FAILURE;
	}

	return (tStatus);
}

/**
 * Register to receive unsolicited status events from the nav.
 *
 * @param
 *      callback -- pointer to function to receive callback
 *      pvParam  -- PVOID to be received with callback
 *
 * @retval
 *      METANAV_SUCCESS if successful
 *      METANAV_FAILURE if unsuccessful
 */
METANAV_STATUS cMetaNav::RegisterCallback(METANAV_CALLBACK callback, PVOID pvParam)
{
    /* Register callback with USRAPI */
    if (UsrRegisterCallback( (USR_CALLBACK)callback, pvParam) != USR_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("cMetaNav::RegisterCallback: Could not register USRAPI callback!\n"));
        return (METANAV_FAILURE);
    }
    return (METANAV_SUCCESS);
}

/**
 * Remove callback that was registered.
 *
 * @param
 *      callback -- pointer to function that was registered for callbacks
 *
 * @retval
 *      METANAV_SUCCESS if successful
 *      METANAV_FAILURE if unsuccessful
 */
METANAV_STATUS cMetaNav::RemoveCallback(METANAV_CALLBACK callback)
{
    /* Remove callback from USRAPI */
    if (UsrRemoveCallback( (USR_CALLBACK)callback) != USR_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("cMetaNav::RemoveCallback: Could not remove USRAPI callback!\n"));
        return (METANAV_FAILURE);