windows-xp/Source/XPSP1/NT/multimedia/media/deluxe2/cdplay/database.cpp

/******************************Module*Header*******************************\
* Module Name: database.c
*
* This module implements the database routines for the CD Audio app.
* The information is stored in the ini file "cdaudio.ini" which should
* be located in the nt\windows directory.
*
* Warning:
*   These functions ARE NOT THREAD safe.
*   The functions in this file MUST only be called on the UI thread.  Before
*   calling any of the functions the CALLER MUST call LockTableOfContents
*   for the specified cdrom device.
*
* Author:
*   Rick Turner (ricktu) 31-Jan-1992
*
*
* Revision History:
*
*   04-Aug-1992 (ricktu)    Incorperated routines from old cdaudio.c,
*                           and made work w/new child window framework.
*
*
* Copyright (c) 1993 - 1995 Microsoft Corporation.  All rights reserved.
\**************************************************************************/
#pragma warning( once : 4201 4214 )

#define NOOLE
#include <windows.h>
#include "playres.h"
#include "cdapi.h"
#include "cdplayer.h"
#include "database.h"
#include "literals.h"


#include <string.h>
#include <stdio.h>
#include <tchar.h>

#include "trklst.h"

#include "..\cdnet\cdnet.h"
#include "..\cdopt\cdopt.h"

/* -------------------------------------------------------------------------
** Private entry points
** -------------------------------------------------------------------------
*/
DWORD
ComputeOldDiscId(
    int cdrom
    );


BOOL
ReadEntry(
    int cdrom,
    DWORD dwId);


/*****************************Private*Routine******************************\
* ComputeOldDiscId
*
* This routine computes a unique ID based on the information
* in the table of contexts a given disc.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
DWORD
ComputeOldDiscId(
    int cdrom
    )
{
    int NumTracks,i;
    DWORD DiscId = 0;


    NumTracks = g_Devices[ cdrom ]->toc.LastTrack -
		g_Devices[ cdrom ]->toc.FirstTrack;

    for ( i = 0; i < NumTracks; i++ )  {
	DiscId += ( (TRACK_M(cdrom,i) << 16) +
		    (TRACK_S(cdrom,i) <<  8) +
		     TRACK_F(cdrom,i) );
    }

    return DiscId;

}


/******************************Public*Routine******************************\
* ComputeNewDiscId
*
* Just call mci to get the product ID.
*
* History:
* dd-mm-94 - StephenE - Created
*
\**************************************************************************/
DWORD
ComputeNewDiscId(
    int cdrom
    )
{
#ifdef USE_IOCTLS
    return ComputeOrgDiscId( cdrom );
#else

    MCI_INFO_PARMS  mciInfo;
    TCHAR           szBuffer[32];
    DWORD           dwRet;

    mciInfo.lpstrReturn = szBuffer;
    mciInfo.dwRetSize   = sizeof(szBuffer)/sizeof(TCHAR);

    dwRet = mciSendCommand( g_Devices[cdrom]->hCd, MCI_INFO,
			    MCI_INFO_MEDIA_IDENTITY,
			    (DWORD_PTR)(LPVOID)&mciInfo );

    if ( dwRet != MMSYSERR_NOERROR ) {
	return 0L;
    }

    _stscanf(szBuffer, TEXT("%ld"), &dwRet );

    return dwRet;

#endif
}



/*****************************Private*Routine******************************\
* ComputeOrgDiscId
*
* This routine computes a unique ID based on the information
* in the table of contexts a given disc. This is done by taking
* the TMSF value for each track and XOR'ing it with the previous
* quantity shifted left one bit.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
DWORD
ComputeOrgDiscId(
    int cdrom
    )
{
    int NumTracks,i;
    DWORD DiscId = 0;


    NumTracks = g_Devices[ cdrom ]->toc.LastTrack -
		g_Devices[ cdrom ]->toc.FirstTrack + 1;

    for ( i = 0; i < NumTracks; i++ ) {
	DiscId = (DiscId << 1) ^
		   ((i<<24) +
		    (TRACK_M(cdrom,i) << 16) +
		    (TRACK_S(cdrom,i) <<  8) +
		     TRACK_F(cdrom,i) );
    }

    return DiscId;

}


/*****************************Private*Routine******************************\
* ErasePlayList
*
* Erases the current play list.  This includes freeing the memory
* for the nodes in the play list, and resetting the current track
* pointer to NULL.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
VOID
ErasePlayList(
    int cdrom
    )
{

    PTRACK_PLAY temp, temp1;

    //
    // Free memory for each track in play list
    //

    temp = PLAYLIST( cdrom );
    while (temp!=NULL) {

	temp1 = temp->nextplay;
	LocalFree( (HLOCAL)temp );
	temp = temp1;

    }

    //
    // Reset pointers
    //

    PLAYLIST( cdrom ) = NULL;
    CURRTRACK( cdrom ) = NULL;
}



/******************************Public*Routine******************************\
* EraseSaveList
*
* Erases the current save list.  This includes freeing the memory
* for the nodes in the save list.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
VOID
EraseSaveList(
    int cdrom
    )
{

    PTRACK_PLAY temp, temp1;

    //
    // Free memory for each track in play list
    //


    temp = SAVELIST( cdrom );
    while ( temp != NULL ) {

	temp1 = temp->nextplay;
	LocalFree( (HLOCAL)temp );
	temp = temp1;

    }

    //
    // Reset pointers
    //

    SAVELIST( cdrom ) = NULL;

}


/*****************************Private*Routine******************************\
* EraseTrackList
*
* Erases the current track list.  This includes freeing the memory
* for the nodes in the track list, and resetting the track list
* pointer to NULL.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
VOID
EraseTrackList(
    int cdrom
    )
{

    PTRACK_INF temp, temp1;

    //
    // Free memory for each track in track list
    //

    temp = ALLTRACKS( cdrom );
    while ( temp != NULL ) {

	temp1 = temp->next;
	LocalFree( (HLOCAL)temp );
	temp = temp1;
    }

    //
    // Reset pointers
    //

    ALLTRACKS( cdrom ) = NULL;

}

/******************************Public*Routine******************************\
* CopyPlayList
*
* Returns a copy of the playlist pointed to by p.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
PTRACK_PLAY
CopyPlayList(
    PTRACK_PLAY p
    )
{

    PTRACK_PLAY t,t1,tend,tret;

    tret = tend = NULL;

    //
    // Duplicate list pointed to by p.
    //

    t = p;
    while( t!=NULL ) {

	t1 = (PTRACK_PLAY)AllocMemory( sizeof(TRACK_PLAY) );
	t1->TocIndex = t->TocIndex;
	t1->min = t->min;
	t1->sec = t->sec;
	t1->nextplay = NULL;
	t1->prevplay = tend;

	if (tret==NULL) {

	    tret = tend = t1;
	}
	else {

	    tend->nextplay = t1;
	    tend = t1;
	}

	t = t->nextplay;

    }

    return(tret);

}


/*****************************Private*Routine******************************\
* ResetPlayList
*
* Resets play order for the disc.  Used to initialize/reset
* the play list.  This is done by reseting the doubly-linked list
* of tracks in the g_Devices[...]->CdInfo.PlayList.[prevplay,nextplay]
* pointers.  All the tracks on the CD are stored in a singly linked list
* pointed to by g_Devices[...]->CdInfo.AllTracks pointer.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
VOID
ResetPlayList(
     int cdrom
    )
{
    PTRACK_INF t;
    PTRACK_PLAY temp, prev;


    //
    // Kill old play list
    //

    ErasePlayList( cdrom );
    EraseSaveList( cdrom );

    //
    // Duplicate each node in AllTracks and insert in-order
    // in SaveList list.  The SaveList is the master which is
    // used for the playlist.
    //

    t = ALLTRACKS( cdrom );
    prev = NULL;

    while (t!=NULL) {

	temp = (PTRACK_PLAY)AllocMemory( sizeof(TRACK_PLAY) );

	temp->TocIndex = t->TocIndex;
	temp->min = 0;
	temp->sec = 0;
	temp->prevplay = prev;
	temp->nextplay = NULL;

	if (prev!=NULL) {

	    prev->nextplay = temp;
	}
	else {

	    SAVELIST( cdrom ) = temp;
	}

	prev = temp;
	t=t->next;

    }

    PLAYLIST( cdrom ) = CopyPlayList( SAVELIST( cdrom) );
}

void CreateNewEntry(int cdrom, DWORD key, PCDROM_TOC lpTOC)
{
    /*
    ** This is a new entry, fill it in but don't store it in the database.
    */

    PTRACK_INF  temp, temp1;
    PTRACK_PLAY pTempCurrTrack = CURRTRACK(cdrom);
    int i, num;
    int nSaveTrack = -1;

    if (CURRTRACK(cdrom))
    {
        nSaveTrack = CURRTRACK(cdrom)->TocIndex;
    }

    ErasePlayList( cdrom );
    EraseSaveList( cdrom );
    EraseTrackList( cdrom );

    g_Devices[ cdrom ]->CdInfo.iFrameOffset = NEW_FRAMEOFFSET;
	g_Devices[ cdrom ]->CdInfo.IsVirginCd = TRUE;
    g_Devices[ cdrom ]->CdInfo.Id = key;

	wsprintf( (LPTSTR)ARTIST( cdrom ), IdStr( STR_NEW_ARTIST ) );
	wsprintf( (LPTSTR)TITLE( cdrom ), IdStr( STR_NEW_TITLE ) );

	if (lpTOC)
    {
        NUMTRACKS( cdrom ) = num = lpTOC->LastTrack - lpTOC->FirstTrack + 1;
    }
    else
    {
        num = NUMTRACKS( cdrom );
    }


	/*
	** Create generic playlist, which is all audio tracks
	** played in the order they are on the CD.  First, create
	** a singly linked list that contains all the tracks.
	** Then, create a double linked list, using the nodes of
	** from the single linked list for the play list.
	*/


	for( i = 0; i < num; i++ ) {

	    /*
	    ** Create storage for track
	    */

	    temp = (PTRACK_INF)AllocMemory( sizeof(TRACK_INF) );

	    /*
	    ** Initialize information (storage already ZERO initialized)
	    */

	    wsprintf( (LPTSTR)temp->name, IdStr( STR_INIT_TRACK ), i+1 );
	    temp->TocIndex = i;
	    temp->next = NULL;

	    /*
	    ** Add node to singly linked list of all tracks
	    */

	    if (i == 0) {

		temp1 = ALLTRACKS( cdrom ) = temp;
	    }
	    else {

		temp1->next = temp;
		temp1 = temp;
	    }
	}

	/*
	** Generate generic play list (all tracks in order)
	*/

	ResetPlayList( cdrom );

    if (nSaveTrack > -1)
    {
	    PTRACK_PLAY  playlist;
	    for( playlist = PLAYLIST(cdrom);
             playlist != NULL;
             playlist = playlist->nextplay )
	    {
            if (playlist->TocIndex == nSaveTrack)
            {
                CURRTRACK(cdrom) = playlist;
            }
        }
    }
}

void RecomputePlayTimes(int dCdrom)
{
    /*
    ** Compute PLAY length
    */
    PTRACK_PLAY pp;
    int m, s, mtemp, stemp;
    
    m = s = 0;
    for( pp = PLAYLIST(dCdrom); pp != NULL; pp = pp->nextplay )
    {

        FigureTrackTime( dCdrom, pp->TocIndex, &mtemp, &stemp );

        m+=mtemp;
        s+=stemp;

        pp->min = mtemp;
        pp->sec = stemp;
    }

    //also refresh the savelist
    for( pp = SAVELIST(dCdrom); pp != NULL; pp = pp->nextplay )
    {

        FigureTrackTime( dCdrom, pp->TocIndex, &mtemp, &stemp );

        pp->min = mtemp;
        pp->sec = stemp;
    }

    m += (s / 60);
    s =  (s % 60);

    CDTIME(dCdrom).TotalMin = m;
    CDTIME(dCdrom).TotalSec = s;

    /*
    ** Make sure that the track time displayed in the LED and the
    ** status bar is correct.  If we have a current track and the
    ** CD is playing or paused then everything is OK.  Otherwise, we
    ** have to reset the track times.
    */
    if ( CURRTRACK( dCdrom ) != NULL ) {

        if ( STATE(dCdrom) & CD_STOPPED ) {

            CDTIME(dCdrom).TrackTotalMin = CURRTRACK( dCdrom )->min;
            CDTIME(dCdrom).TrackRemMin   = CURRTRACK( dCdrom )->min;

            CDTIME(dCdrom).TrackTotalSec = CURRTRACK( dCdrom )->sec;
            CDTIME(dCdrom).TrackRemSec   = CURRTRACK( dCdrom )->sec;
        }

    }
    else {

        CDTIME(dCdrom).TrackTotalMin = 0;
        CDTIME(dCdrom).TrackRemMin   = 0;
        CDTIME(dCdrom).TrackTotalSec = 0;
        CDTIME(dCdrom).TrackRemSec   = 0;
    }

    if (dCdrom == g_CurrCdrom)
    {
        UpdateDisplay( DISPLAY_UPD_DISC_TIME );
    }
}

BOOL GetInternetDatabase(int cdrom, DWORD key, BOOL fHitNet, BOOL fManual, HWND hwndCallback, void* pData)
{
    if (!g_fBlockNetPrompt)
    {
        if (fHitNet)
        {
            ICDNet* pICDNet = NULL;
            if (SUCCEEDED(CDNET_CreateInstance(NULL, IID_ICDNet, (void**)&pICDNet)))
            {
		            pICDNet->SetOptionsAndData((void*)g_pSink->GetOptions(),(void*)g_pSink->GetData());
                    pICDNet->Download(g_Devices[ cdrom ]->hCd,g_Devices[cdrom]->drive,key,(LPCDTITLE)pData,fManual,hwndCallback);
                    pICDNet->Release();
            }
            return FALSE; //couldn't find title just now, catch it on the callback
        }
    }

    if ( ReadEntry(cdrom, key))
    {
        return TRUE;
    }

    if (!fHitNet)
    {
        CreateNewEntry(cdrom, key, NULL);
        RecomputePlayTimes(cdrom);
    }

    return FALSE;
}

/*****************************Private*Routine******************************\
* ReadEntry
*
* Try to read entry for new disc from  database ini file.
* The section name we are trying to read is a hex
* value of the disc id.  If the sections is found,
* fill in the data for the disc in the cdrom drive.
*
* This function uses over 16K of stack space !!
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
BOOL
ReadEntry(
    int cdrom,
    DWORD dwId)
{
    UINT        i;
    int         numtracks, numplay;
    PTRACK_INF  temp, curr;
    PTRACK_PLAY temp1, prev;
    BOOL        fRewriteEntry = FALSE;
    LPCDDATA    pData = NULL;

    g_Devices[ cdrom ]->CdInfo.iFrameOffset = NEW_FRAMEOFFSET;

    pData = (LPCDDATA)g_pSink->GetData();
    if( !pData )
    {
        //Can't create the options object, so fail
        return (FALSE);
    }

    pData->AddRef();
    
    //
    // Try to read in title from the options database
    //

    if (!pData->QueryTitle(dwId))
    {
        pData->Release();
        return (FALSE);
    }

    //
    // We found an entry for this disc, so copy all the information
    // from the title database

    LPCDTITLE pCDTitle = NULL;

    if (FAILED(pData->LockTitle(&pCDTitle,dwId)))
    {
        pData->Release();
        return FALSE;
    }

    _tcscpy(g_Devices[ cdrom ]->CdInfo.Title,pCDTitle->szTitle); 

    numtracks = pCDTitle->dwNumTracks;

    // Make sure there is at least one track!!!
    if (0 == numtracks)
    {
    	fRewriteEntry = TRUE;
    }

    g_Devices[ cdrom ]->CdInfo.NumTracks = numtracks;
    _tcscpy(g_Devices[ cdrom ]->CdInfo.Artist,pCDTitle->szArtist);

    //
    // Validate the stored track numbers
    //
    if (g_Devices[cdrom]->fIsTocValid)
    {
	    int    maxTracks;  // validate the high point in database

	    maxTracks = g_Devices[cdrom]->toc.LastTrack;

	    if (numtracks > maxTracks)
        {
	        // Current database contains invalid data
	        // this can result in the CD not playing at all as the end
	        // point is likely to be invalid
	        g_Devices[ cdrom ]->CdInfo.NumTracks
	          = numtracks
	          = maxTracks;
	        fRewriteEntry = TRUE;
	    }
    }

    //
    // Read the track list information
    //

    for (i=0, curr = NULL; i < (UINT)numtracks; i++)
    {
	    temp = (PTRACK_INF)AllocMemory( sizeof(TRACK_INF) );
	    temp->TocIndex = i;
	    temp->next = NULL;

        _tcscpy(temp->name,pCDTitle->pTrackTable[i].szName);

	    if (curr==NULL)
        {
	        ALLTRACKS( cdrom ) = curr = temp;

	    } else
        {

	        curr->next = temp;
	        curr = temp;

	    }
    }

    // Make sure there is at least one entry in TRACK list
    if (ALLTRACKS(cdrom) == NULL)
    {
	    fRewriteEntry = TRUE;
    }

    //
    // if we detected a problem in the ini file, or the entry is an
    // old format, rewrite the section.
    //

    if (fRewriteEntry)
    {
	    //
	    // Generate generic play list (all tracks in order)
	    //

	    ResetPlayList( cdrom );

    }
    else
    {
	    //
	    // Read play list (order) information and construct play list doubly
	    // linked list
	    //

	    numplay = pCDTitle->dwNumPlay;
        if (numplay == 0)
        {
            numplay = pCDTitle->dwNumTracks;
        }

	    prev = NULL;

        int iCurrTrack = -1;

        if (CURRTRACK(cdrom)!=NULL)
        {
            iCurrTrack = CURRTRACK(cdrom)->TocIndex;
        }

        EraseSaveList(cdrom);
        ErasePlayList(cdrom);

	    for (int tr_index = 0; tr_index < numplay; tr_index++)
        {
	        /*
	        ** Assert that i is a valid index.
	        **  ie 0 <= i <= (numtracks - 1)
	        */

            if (pCDTitle->dwNumPlay > 0)
            {
                i = pCDTitle->pPlayList[tr_index];
            }
            else
            {
                i = tr_index;
            }

	        i = min( ((UINT)numtracks - 1), max( 0, i ) );

	        temp1 = (PTRACK_PLAY)AllocMemory( sizeof(TRACK_PLAY) );
	        temp1->TocIndex = (int)i;
	        temp1->min = 0;
	        temp1->sec = 0;
	        temp1->prevplay = prev;
	        temp1->nextplay = NULL;

	        if (prev==NULL)
            {
    		    SAVELIST( cdrom ) = temp1;
	        }
            else
            {
    		    prev->nextplay  = temp1;
	        }
	        prev = temp1;
	    }

	    // Make sure there is at least one entry in SAVED list
	    if (SAVELIST(cdrom) == NULL)
	    {
	        // Nope, use default list instead
	        ResetPlayList( cdrom );
	    }

	    PLAYLIST( cdrom ) = CopyPlayList( SAVELIST( cdrom ) );

        //reset current track if necessary
        if (iCurrTrack != -1)
        {
            BOOL fFound = FALSE;

            for (PTRACK_PLAY pp = PLAYLIST(cdrom); pp != NULL; pp = pp->nextplay )
            {
                if ( pp->TocIndex == iCurrTrack )
                {
                    fFound = TRUE;
                    break;
                }
            } //end for

            if (fFound)
            {
                CURRTRACK(cdrom) = pp;
            }
            else
            {
                /*
                ** If the track was not found in the new track list and this
                ** cd is currently playing then stop it.
                */
                if ( (STATE(cdrom) & (CD_PLAYING | CD_PAUSED)) )
                {

                    SendDlgItemMessage( g_hwndApp, IDM_PLAYBAR_STOP,
                                        WM_LBUTTONDOWN, 1, 0 );

                    SendDlgItemMessage( g_hwndApp, IDM_PLAYBAR_STOP,
                                        WM_LBUTTONUP, 1, 0 );
                }

                CURRTRACK(cdrom) = PLAYLIST(cdrom);
            }
        }

        /*
        ** If we were previously in "Random" mode shuffle the new
        ** playlist.
        */
        if (!g_fSelectedOrder)
        {
            ComputeSingleShufflePlayList(cdrom);
        }

        RecomputePlayTimes(cdrom);
    }

    //unlock title data, don't persist it
    pData->UnlockTitle(pCDTitle,FALSE);
    pData->Release();

    return TRUE;
}

/******************************Public*Routine******************************\
* AddFindEntry
*
* Search the database file for the current disc,  if found, read the
* information, otherwise, generate some default artist and track names etc.
* but don't store this in the database.  A new entry is only added to the
* database after the user has used the "Edit Track Titles" dialog box.
*
* The design of this function is complicated by the fact that we have to
* support two previous attempts at generating CDplayer keys.  Also, we try
* to support the MusicBox key format now that it is compatible with the
* new CDplayer format.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
VOID
AddFindEntry(
    int cdrom,
    DWORD key,
    PCDROM_TOC lpTOC
    )
{
    /*
    ** Kill off old PlayList, Save lists if they exists.
    */

    ErasePlayList( cdrom );
    EraseSaveList( cdrom );
    EraseTrackList( cdrom );

    /*
    ** Check ini file for an existing entry
    **
    ** First Look in cdplayer.ini using the new key, return if found
    */

    // We initialize this field early, otherwise ReadEntry will not be
    // able to save any new information (or lose invalid).
    g_Devices[ cdrom ]->CdInfo.save = TRUE;

    if ( ReadEntry(cdrom, key) )
    {
	    return;
    }

    /*
    ** Initialize these fields
    */
    g_Devices[ cdrom ]->CdInfo.IsVirginCd = FALSE;
    g_Devices[ cdrom ]->CdInfo.Id = key;

	/*
	** dstewart: Try to get the info from the net
	*/
	if ( GetInternetDatabase(cdrom, key, TRUE, FALSE, GetParent(g_hwndApp),NULL) )
	{
        return;
    }
	/*
	** end dstewart
	*/

    CreateNewEntry(cdrom,key,lpTOC);
}