mvplaylistdb.cpp

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

/*****************************************************************************
******************************************************************************
**                                                                          **
**  Copyright (c) 2005-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 mvplaylistdb.cpp
 *
 * API to the Movie Playlist Database.
 * The Movie Playlist Database handles the storage of and access to Movie Playlist data.
 *
 * $Id: mvplaylistdb.cpp,v 1.33 2007/01/04 22:24:49 rbehe Exp $
 */

#include <string.h>
#include "vdvd_types.h"
#include "loader_app.h"
#include "mvplaylistdb.h"
#include "osapi.h"
#include "utility.h"
#include "dbgprint.h"
#ifdef DMALLOC
#include "dmalloc.h"
#endif

/* Debug macros */
#define DBG_MPLS_DB DBG_ERROR
#define DBG_ON(x) (DBG_MPLS_DB >= x)

#define PLAYLIST_MARK_LENGTH 14

/**
 * Local handle
 */
typedef struct tagMPLS_DB_HANDLE
{
    LOADER_HANDLE hLoader;
    MOVPLAYLIST   tMovPlayListData;
    OS_SEM_ID     semMutex;
} MPLS_DB_HANDLE;

/**
 * Local variables
 */
static MPLS_DB_HANDLE *pMPLS_DB = NULL;

static MPLS_STATUS mplsLoadIndicator(LOADER_FILE_HANDLE file);
static MPLS_STATUS mplsLoadAppInfoPlayList(LOADER_FILE_HANDLE file, uint32 start_address, APPINFOPLAYLIST_TABLE *pAppInfoPlayList);
static MPLS_STATUS mplsLoadPlayList(LOADER_FILE_HANDLE file, uint32 start_address, PLAYLIST_TABLE *pPlayList);
static MPLS_STATUS mplsUnLoadPlayList(PLAYLIST_TABLE *pPlayList);
static MPLS_STATUS mplsLoadPlayList_PlayItem(LOADER_FILE_HANDLE file, PLAYITEM *pPlayItem);
static MPLS_STATUS mplsUnLoadPlayList_PlayItem(PLAYITEM *pPlayItem);
static MPLS_STATUS mplsLoadPlayList_STN_table(LOADER_FILE_HANDLE file, STN_TABLE *pSTN_table);
static MPLS_STATUS mplsUnLoadPlayList_STN_table(STN_TABLE *pSTN_table);
static MPLS_STATUS mplsLoadPlayList_SubPath(LOADER_FILE_HANDLE file, SUBPATH *pSubpath);
static MPLS_STATUS mplsUnLoadPlayList_SubPath(SUBPATH *pSubpath);
static MPLS_STATUS mplsLoadPlayList_SubPlayItem(LOADER_FILE_HANDLE file, SUBPLAYITEM *pSubPlayItem);
static MPLS_STATUS mplsUnLoadPlayList_SubPlayItem(SUBPLAYITEM *pSubPlayItem);
static MPLS_STATUS mplsLoadPlayListMark(LOADER_FILE_HANDLE file, uint32 start_address, PLAYLISTMARK_TABLE *pPlaylistMark);


#if DBG_ON(DBG_TRACE)
int gMPLSMemUsage = 0;
#endif

/**
 * MPLSCreate -- Create the Movie Playlist Database
 *
 * @param
 *      tLoader -- handle to the loader.
 *
 * @retval
 *      MPLS_STATUS
 */
MPLS_STATUS MPLSCreate(LOADER_HANDLE tLoader)
{
    MPLS_STATUS tStatus;

#if DBG_ON(DBG_TRACE)
    DbgPrint(("MPLSCreate: sizeof(MPLS_DB_HANDLE) = %d\n", sizeof(MPLS_DB_HANDLE)));
#endif

    /* validate parameter */
    if (tLoader == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("%s: Null pointer!\n", __FUNCTION__));
        return (MPLS_NULL_PTR);
    }

    /* If database is already created, return a failure */
    if (pMPLS_DB != NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("%s: Database already created!\n", __FUNCTION__));
        tStatus = MPLS_FAILURE;
    }
    else
    {
        /* Allocate local handle */
        pMPLS_DB = (MPLS_DB_HANDLE *)OS_MemAlloc(sizeof(MPLS_DB_HANDLE) );
        if (pMPLS_DB == NULL)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("%s: Error allocating local handle!\n", __FUNCTION__));
            tStatus = MPLS_FAILURE;
        }
        else
        {
            /* create mutex sem  */
            pMPLS_DB->semMutex = OS_SemBCreate(OS_SEM_Q_FIFO, OS_SEM_FULL);

            /* Keep loader handle */
            pMPLS_DB->hLoader = tLoader;

            /* intialize movie playlist to NULL */
            memset(&pMPLS_DB->tMovPlayListData, 0, sizeof(MOVPLAYLIST));

            tStatus = MPLS_SUCCESS;
        }
    }

    return (tStatus);
}

/**
 * MPLSDelete -- Delete the movie playlist database
 *
 * @param
 *      none
 *
 * @retval
 *      MPLS_STATUS
 */
MPLS_STATUS MPLSDelete(void)
{
    MPLS_STATUS tStatus;

    /* If database has not been created, return a failure */
    if (pMPLS_DB == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("%s: Database doesn't exist!\n", __FUNCTION__));
        tStatus = MPLS_FAILURE;
    }
    else
    {
        /* unload playlist to free any allocations */
        mplsUnLoadPlayList(&pMPLS_DB->tMovPlayListData.PlayList);

        OS_SemDelete(pMPLS_DB->semMutex);
        pMPLS_DB->semMutex = 0;

        /* free local handle */
        OS_MemFree(pMPLS_DB);
        pMPLS_DB = NULL;
        tStatus  = MPLS_SUCCESS;
    }

    return (tStatus);
}

/**
 * MPLSLoad -- Load the Movie PlayList data from BDROM disc into the database.
 *
 * @param
 *      mpls_number - Which movie play list to load.
 *
 * @retval
 *      MPLS_STATUS
 */
MPLS_STATUS MPLSLoad(uint32 mpls_number)
{
    LOADER_FILE_HANDLE  mpls_file;
    LOADER_FILE_HANDLE  mpls_backup;
    MPLS_STATUS         tStatus;
    UBYTE               pTmpBuf[16];
    char                filename[64];
    ULONG               ulPlaylistStartAddr;
    ULONG               ulPlaylistMarkStartAddr;

    if (pMPLS_DB == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: Database not created!\n"));
        tStatus = MPLS_FAILURE;
        goto errout_1;
    }

    /* take mutex while we load the movie playlist file */
    OS_SemTake(pMPLS_DB->semMutex, OS_WAIT_FOREVER);

    /* Open the movie playlist */
    snprintf(filename, 64, "/mnt/cdrom/BDMV/PLAYLIST/%.5lu.mpls", mpls_number);
    if (LoaderFileOpen(pMPLS_DB->hLoader, filename, &mpls_file) != LOADER_SUCCESS)
    {
        mpls_file = 0;
    }

    /* Open the backup copy */
    snprintf(filename, 64, "/mnt/cdrom/BDMV/BACKUP/PLAYLIST/%.5lu.mpls", mpls_number);
    if (LoaderFileOpen(pMPLS_DB->hLoader, filename, &mpls_backup) != LOADER_SUCCESS)
    {
        mpls_backup = 0;
    }

    /* make sure at least one of the playlist files opened successfuly */
    if (mpls_file == 0)
    {
        if (mpls_backup == 0)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: Could not open movie playlist file!\n"));
            tStatus = MPLS_FAILURE;
            goto errout_1;
        }
        else
        {
            /* use the backup copy */
            mpls_file   = mpls_backup;
            mpls_backup = 0;
        }
    }

    /* Load the Type indicator and version number from the file */
    tStatus = mplsLoadIndicator(mpls_file);
    if (tStatus != MPLS_SUCCESS)
    {
        /* Main file failed so try the backup file */
        if (mpls_backup == 0)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: Failed to load indicator!\n"));
            goto errout_2;
        }
        else
        {
            /* Load the Type indicator and version number from the backup file */
            tStatus = mplsLoadIndicator(mpls_backup);
            if (tStatus != MPLS_SUCCESS)
            {
                DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: Failed to load indicator!\n"));
                goto errout_2;
            }
        }
    }

    /* Read up to the reserved field */
    if (LoaderFileRead(pMPLS_DB->hLoader, mpls_file, (PVOID)pTmpBuf, 8, NULL) != LOADER_SUCCESS)
    {
        if (mpls_backup == 0)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: Failed to read type indicator!\n"));
            tStatus = MPLS_FILE_ERROR;
            goto errout_2;
        }

        /* try again with backup */
        if (LoaderFileRead(pMPLS_DB->hLoader, mpls_backup, (PVOID)pTmpBuf, 8, NULL) != LOADER_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: Failed to read type indicator!\n"));
            tStatus = MPLS_FILE_ERROR;
            goto errout_2;
        }
    }

    /* Read the PlayList Start Address */
    ulPlaylistStartAddr = MAKE_DWORD(&pTmpBuf[0]);

    /* Read the PlayListMark Start Address */
    ulPlaylistMarkStartAddr = MAKE_DWORD(&pTmpBuf[4]);

    /*
     * AppInfoPlayList()
     ************************************************************************/
    tStatus = mplsLoadAppInfoPlayList(mpls_file, 40, &pMPLS_DB->tMovPlayListData.AppInfoPlayList);
    if (tStatus != MPLS_SUCCESS)
    {
        if (mpls_backup == 0)
        {
            /* we're either already using the backup file or the backup file isn't valid */
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: mplsLoadAppInfoPlayList Failed!\n"));
            goto errout_2;
        }

        /* try again with backup */
        tStatus = mplsLoadAppInfoPlayList(mpls_backup, 40, &pMPLS_DB->tMovPlayListData.AppInfoPlayList);
        if (tStatus != MPLS_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: mplsLoadAppInfoPlayList Failed!\n"));
            goto errout_2;
        }
    }

    /*
     * PlayList()
     ************************************************************************/
    tStatus = mplsLoadPlayList(mpls_file, ulPlaylistStartAddr, &pMPLS_DB->tMovPlayListData.PlayList);
    if (tStatus != MPLS_SUCCESS)
    {
        if (mpls_backup == 0)
        {
            /* we're either already using the backup file or the backup file isn't valid */
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: mplsLoadPlayList Failed!\n"));
            goto errout_2;
        }

        /* get the start offset from the backup file in case the problem was a corrupted offset */
        if (LoaderFileSeek(pMPLS_DB->hLoader, mpls_backup, LOADER_SEEK_SET, 8) == LOADER_SUCCESS)
        {
            if (LoaderFileRead(pMPLS_DB->hLoader, mpls_backup, (PVOID)pTmpBuf, 4, NULL) == LOADER_SUCCESS)
            {
                ulPlaylistStartAddr = MAKE_DWORD(&pTmpBuf[0]);
            }
        }

        /* try again with backup */
        tStatus = mplsLoadPlayList(mpls_backup, ulPlaylistStartAddr, &pMPLS_DB->tMovPlayListData.PlayList);
        if (tStatus != MPLS_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: mplsLoadPlayList Failed!\n"));
            goto errout_2;
        }
    }

    /*
     * PlayListMark()
     ************************************************************************/
    tStatus = mplsLoadPlayListMark(mpls_file, ulPlaylistMarkStartAddr, &pMPLS_DB->tMovPlayListData.PlayListMark);
    if (tStatus != MPLS_SUCCESS)
    {
        if (mpls_backup == 0)
        {
            /* we're either already using the backup file or the backup file isn't valid */
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: mplsLoadPlayListMark Failed!\n"));
            goto errout_2;
        }

        /* get the start offset from the backup file in case the problem was a corrupted offset */
        if (LoaderFileSeek(pMPLS_DB->hLoader, mpls_backup, LOADER_SEEK_SET, 12) == LOADER_SUCCESS)
        {
            if (LoaderFileRead(pMPLS_DB->hLoader, mpls_backup, (PVOID)pTmpBuf, 4, NULL) == LOADER_SUCCESS)
            {
                ulPlaylistMarkStartAddr = MAKE_DWORD(&pTmpBuf[0]);
            }
        }

        /* try again with backup */
        tStatus = mplsLoadPlayListMark(mpls_backup, ulPlaylistMarkStartAddr, &pMPLS_DB->tMovPlayListData.PlayListMark);
        if (tStatus != MPLS_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("MPLSLoad: mplsLoadPlayListMark Failed!\n"));