loader_app.cpp

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

/******************************************************************************
*******************************************************************************
**                                                                           **
**  Copyright (c) 2006 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 loader_app.cpp
 *
 * $Revision: 1.29 $ 
 *
 * win32 implementation
 *
 */

#include "loader_app.h"
#include "loader_win32.h"
#include "arch.h"
#include "dbgprint.h"
#include "osapi.h"
#include "css.h"
#include <string.h>
#include <assert.h>



/********************************************************************************
                                     CONSTANTS
 ********************************************************************************/

#define     DEBUG_TRACE             1
#define     DEBUG_INFO              2
#define     DEBUG_LOADER_APP        (DEBUG_INFO)
#define     DEBUG_ON(x)             (DEBUG_LOADER_APP & x)




/******************************************************************************
*******************************************************************************
**                                                                           **
**  Private types                                                            **
**                                                                           **
*******************************************************************************
******************************************************************************/



typedef struct tagLoaderData
{
    OS_SEM_ID       loaderMutex;
    WIN32Loader*    win32Loader;
    LOADER_TYPE     loaderType;        // media type
    BYTE            regionMask;        // region code mask
    ULONG           trayStatus;        // current tray status (open/closed)

} LoaderData;



/******************************************************************************
*******************************************************************************
**                                                                           **
**  Private function prototypes                                              **
**                                                                           **
*******************************************************************************
******************************************************************************/



static const char* LoaderStripMountPrefix( const char* path );




/**
 * Creates a handle to a loader device, initializes any global variables,
 * allocates any required memory, and returns a pointer to the device handle.
 *
 * @param busType        not used for this implementation
 * @param deviceNumber   not used for this implementation
 */
LOADER_HANDLE LoaderCreate(LOADER_BUS_TYPE busType, ULONG deviceNumber)
{
    LoaderData*    loaderData;

    UNUSED_PARAM(busType);
    UNUSED_PARAM(deviceNumber);

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderCreate\n"));    

    loaderData = new LoaderData;
    assert( loaderData != NULL );

    memset(loaderData,0,sizeof(LoaderData));

    loaderData->loaderMutex = OS_SemBCreate(OS_SEM_Q_FIFO, OS_SEM_FULL);
    assert(loaderData->loaderMutex != NULL);

    loaderData->win32Loader = new WIN32Loader;
    assert(loaderData->win32Loader != NULL);

    loaderData->win32Loader->Initialize();

    loaderData->loaderType = LOADER_TYPE_UNKNOWN;
    loaderData->trayStatus = LOADER_TRAY_UNKNOWN;
    loaderData->regionMask = 0;

    return ( loaderData );
}




/**
 * Stops the storage media if necessary, closes the current session and frees
 * any memory allocated during the LoaderCreate() call.
 *
 * @param tLoader   The loader handle.
 */
LOADER_ERR LoaderDestroy(LOADER_HANDLE tLoader)
{
    LoaderData* loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderDestroy\n"));

    if ( loaderData->win32Loader != NULL ) 
    {
        loaderData->win32Loader->Destroy();
        delete( loaderData->win32Loader );
        loaderData->win32Loader = NULL;
    }

    OS_SemDelete(loaderData->loaderMutex);

    delete ( loaderData );
    return ( LOADER_SUCCESS );
}




/**
 * Stops the disc if necessary, closes the session, and opens the tray holding
 * the disc.
 *
 * @param tLoader   The loader handle.
 */
LOADER_ERR LoaderOpenTray(LOADER_HANDLE tLoader)
{
    LOADER_ERR  loader_error;
    LoaderData* loaderData;

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderOpenTray\n"));    

    loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );

    OS_SemTake(loaderData->loaderMutex, OS_WAIT_FOREVER);

    if ( loaderData->win32Loader->OpenTray() != WIN32LOADER_SUCCESS )
    {
        loaderData->trayStatus = LOADER_TRAY_UNKNOWN;
        loader_error           = LOADER_FAILURE;
    }
    else
    {
        loaderData->trayStatus = LOADER_TRAY_OPEN;
        loader_error           = LOADER_SUCCESS;
    }

    OS_SemGive(loaderData->loaderMutex);

    return ( loader_error );
}





/**
 * Loads a disc into the device, and prepares everything needed to start the
 * disc.
 *
 * @param tLoader - The loader handle.
 */
LOADER_ERR LoaderCloseTray(LOADER_HANDLE tLoader)
{
    LOADER_ERR  loader_error;
    LoaderData* loaderData;


    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderCloseTray\n"));    

    loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );

    OS_SemTake(loaderData->loaderMutex, OS_WAIT_FOREVER);

    if ( loaderData->win32Loader->CloseTray() != WIN32LOADER_SUCCESS )
    {
        loaderData->trayStatus = LOADER_TRAY_UNKNOWN;
        loader_error           = LOADER_FAILURE;
    }
    else
    {
        loaderData->trayStatus = LOADER_TRAY_CLOSED;
        loader_error           = LOADER_SUCCESS;
    }

    OS_SemGive(loaderData->loaderMutex);

    return ( loader_error );
}





/**
 * Retrieves the current status of the media storage device.
 *
 * @param tLoader   The loader handle.
 * @param pStatus   Status will be returned through this pointer.
 */
LOADER_ERR LoaderGetStatus(LOADER_HANDLE tLoader, LOADER_STATUS *pStatus)
{
    LoaderData* loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );
    assert ( pStatus != NULL );

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderGetStatus\n"));    

    OS_SemTake(loaderData->loaderMutex, OS_WAIT_FOREVER);

    pStatus->ulTrayStatus = loaderData->trayStatus;
    pStatus->ulLoaderBusy = 0;

    OS_SemGive(loaderData->loaderMutex);
    
    return ( LOADER_SUCCESS );
}





/**
 * Detection of the disc type
 *
 * @param tLoader   The loader handle.
 */
LOADER_ERR LoaderStart(LOADER_HANDLE tLoader)
{
    LOADER_ERR  loader_error;
    LoaderData* loaderData;
    DiscType    discType;
 
    loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderStart\n"));    

    OS_SemTake(loaderData->loaderMutex, OS_WAIT_FOREVER);

    if ( loaderData->loaderType != LOADER_TYPE_UNKNOWN )
    {
        DbgPrint(("LoaderStart: error, calling LoaderStart when disc type is already known\n"));
        loader_error = LOADER_FAILURE;
        goto LoaderStartError;
    }

    if ( loaderData->win32Loader->GetDiscType(&discType) != WIN32LOADER_SUCCESS )
    {
        discType = DISC_TYPE_NO_DISC;
    }

    loader_error = LOADER_SUCCESS;
    switch ( discType ) 
    {
        case DISC_TYPE_NO_DISC:
            loaderData->loaderType = LOADER_TYPE_NODISK;
        break;

        case DISC_TYPE_DVD_ROM:
        case DISC_TYPE_DVD_RAM:
        case DISC_TYPE_DVD_R:
        case DISC_TYPE_DVD_MINUS_RW:
        case DISC_TYPE_DVD_PLUS_RW:
            loaderData->loaderType = LOADER_TYPE_DVD;
        break;

        case DISC_TYPE_CDDA:
            loaderData->loaderType = LOADER_TYPE_CDROM;
        break;

        case DISC_TYPE_CDROM_XA:
            loaderData->loaderType = LOADER_TYPE_CDROM;

            // trick for test dvd bdrom test discs
            loaderData->loaderType = LOADER_TYPE_BDROM;       
        break;
    
        default:
            loaderData->loaderType = LOADER_TYPE_UNKNOWN;
        break;
    }


LoaderStartError:

    OS_SemGive(loaderData->loaderMutex);

    return ( loader_error );
}




/**
 * Stops the disc, and cleans up any parameters which may have become obsolete
 * by the stopping of the disc.
 *
 * @param tLoader   The loader handle.
 */
LOADER_ERR LoaderStop(LOADER_HANDLE tLoader)
{
    LoaderData* loaderData;

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderStop\n"));    
 
    loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );

    OS_SemTake(loaderData->loaderMutex, OS_WAIT_FOREVER);

    if (
        ( loaderData->loaderType != LOADER_TYPE_UNKNOWN ) &&
        ( loaderData->loaderType != LOADER_TYPE_NODISK )
       )
    {
        /* stop the drive */
    }


    /* Reset the loader type */
    loaderData->loaderType = LOADER_TYPE_UNKNOWN;

    OS_SemGive(loaderData->loaderMutex);

    return ( LOADER_SUCCESS );
}





/**
 * Returns the type of data storage media loaded into the system.
 *
 * @param tLoader       The loader handle.
 * @param pLoaderType   Pointer to receive the data storage media type.
 */
LOADER_ERR LoaderGetType(LOADER_HANDLE tLoader, LOADER_TYPE *pLoaderType)
{
    LoaderData* loaderData;
 
    loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );
    assert ( pLoaderType != NULL );

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderGetType\n"));

    OS_SemTake(loaderData->loaderMutex, OS_WAIT_FOREVER);

    *pLoaderType = loaderData->loaderType;

    OS_SemGive(loaderData->loaderMutex);

    return (LOADER_SUCCESS);
}






/**
 * Reads a specific number of blocks from the storage media at the specified
 * sector.
 *
 * @param tLoader       The loader handle.
 * @param ulLBA         Sector offset to begin the read from.
 * @param pbData        Pointer to a buffer to receive the data.
 * @param ulNumBlocks   Number of sector sized blocks to be read. 0 and positive numbers only.
 */
LOADER_ERR LoaderSectorRead(LOADER_HANDLE tLoader, ULONG ulLBA, BYTE *pbData, ULONG ulNumBlocks)
{
    LOADER_ERR  loader_error;
    LoaderData* loaderData;
 
    loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );
    assert ( tLoader != NULL );
    assert ( pbData  != NULL );
    assert ( ulNumBlocks > 0 );

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderSectorRead (LBA=%u)\n",ulLBA));

    OS_SemTake(loaderData->loaderMutex, OS_WAIT_FOREVER);

    if ( loaderData->loaderType != LOADER_TYPE_DVD ) 
    {
        loader_error = LOADER_FAILURE;
        goto LoaderSectorReadError;
    }

    if ( loaderData->win32Loader->ReadDVD( pbData, ulLBA, ulNumBlocks ) != WIN32LOADER_SUCCESS )
    {
        loader_error = LOADER_FAILURE;
        goto LoaderSectorReadError;
    }

    loader_error = LOADER_SUCCESS;

LoaderSectorReadError:

    OS_SemGive(loaderData->loaderMutex);

    return ( loader_error );
}





/**
 *  Gets the authentication grant ID (AGID) from the loader.
 *
 *  @param tLoader  The loader handle.
 *  @param pbAgid   Pointer to memory where AGID is stored.
 */
LOADER_ERR LoaderGetAgid(LOADER_HANDLE tLoader, BYTE *pbAgid)
{
    LOADER_ERR  loader_error;
    LoaderData* loaderData;
 
    loaderData = (LoaderData*) tLoader;
    assert ( loaderData != NULL );
    assert ( tLoader != NULL );
    assert ( pbAgid  != NULL );

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderGetAgid\n"));

    OS_SemTake(loaderData->loaderMutex, OS_WAIT_FOREVER);

    assert ( loaderData->loaderType == LOADER_TYPE_DVD );

    loader_error = LOADER_SUCCESS;
    if ( loaderData->win32Loader->GetAgid() != WIN32LOADER_SUCCESS )
    {
        loader_error = LOADER_FAILURE;
    }

    OS_SemGive(loaderData->loaderMutex);

    return ( loader_error );
}





/**
 * Retrieves the Authentication Success Flag status.
 *
 * @param tLoader   The loader handle.
 * @param pbStatus  ASF will be returned through this pointer.
 */
LOADER_ERR LoaderGetASF(LOADER_HANDLE tLoader, BYTE bAgid, BYTE *pbASF)
{
    LoaderData* loaderData;
 
    loaderData = (LoaderData*) tLoader;
    assert ( tLoader != NULL );
    assert ( pbASF   != NULL );