windows-xp/Source/XPSP1/NT/multimedia/media/cdplayer/database.c

/******************************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 "resource.h"
#include "cdapi.h"
#include "cdplayer.h"
#include "database.h"
#include "literals.h"


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


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


BOOL
DeleteEntry(
    DWORD Id
    );

BOOL
WriteEntry(
    int cdrom
    );

BOOL
ReadEntry(
    int cdrom,
    DWORD dwId
    );

BOOL
ReadMusicBoxEntry(
    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)(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) );
}


/*****************************Private*Routine******************************\
* DeleteEntry
*
* The ID format has changed to make the id's for the different CD's
* more unique. This routine will completely delete the old key value
* from the ini file.  We remove it by writing a NULL entry.
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
BOOL
DeleteEntry(
    DWORD Id
    )
{
    TCHAR Section[80];

    wsprintf( Section, g_szSectionF, Id );
    return WritePrivateProfileSection( Section, g_szEmpty, g_IniFileName );
}




/*****************************Private*Routine******************************\
* WriteEntry
*
* Write current disc information into database ini file.
* The section for the current disc (section name is a hex
* value of the disc id) is completely rewritten.
*
* This function uses 64K of stack !!
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
BOOL
WriteEntry(
    int cdrom
    )
{
    TCHAR       *Buffer;
    LPTSTR      s;
    int         i;
    TCHAR       Section[ 10 ];
    PTRACK_INF  temp;
    PTRACK_PLAY temp1;
    BOOL        fRc;

    //
    // Construct ini file buffer, form of:
    //
    //     artist = artist name
    //      title = Title of disc
    //  numtracks = n
    //          0 = Title of track 1
    //          1 = Title of track 2
    //        n-1 = Title of track n
    //      order = 0 4 3 2 6 7 8 ... (n-1)
    //    numplay = # of entries in order list
    //

    //
    // Is it legal to save this information?
    //

    if (!g_Devices[ cdrom ]->CdInfo.save)
        return( TRUE );

    Buffer = AllocMemory( 64000 * sizeof(TCHAR) );
    // note: if the memory allocation fails, AllocMemory will terminate
    // the application

    g_Devices[ cdrom ]->CdInfo.IsVirginCd = FALSE;

    s = Buffer;

    s += 1 + wsprintf( s, g_szEntryTypeF, 1 );
    s += 1 + wsprintf( s, g_szArtistF, g_Devices[ cdrom ]->CdInfo.Artist );
    s += 1 + wsprintf( s, g_szTitleF, g_Devices[ cdrom ]->CdInfo.Title );
    s += 1 + wsprintf( s, g_szNumTracksF, g_Devices[ cdrom ]->CdInfo.NumTracks );

    for ( temp = g_Devices[ cdrom ]->CdInfo.AllTracks;
          temp!=NULL; temp = temp->next ) {

        s += 1 + wsprintf( s, TEXT("%d=%s"), temp->TocIndex, temp->name );
    }

    s += wsprintf( s, g_szOrderF );

    i = 0;
    for ( temp1 = g_Devices[ cdrom ]->CdInfo.SaveList;
          temp1!=NULL; temp1 = temp1->nextplay ) {

        s += wsprintf( s, TEXT("%d "), temp1->TocIndex );
        i++;

    }
    s += 1;

    s += 1 + wsprintf( s, g_szNumPlayF, i );

    //
    // Just make sure there are NULLs at end of buffer
    //

    wsprintf( s, g_szThreeNulls );

    wsprintf( Section, g_szSectionF, g_Devices[ cdrom ]->CdInfo.Id );

    //
    // Try writing buffer into ini file
    //

    fRc = WritePrivateProfileSection( Section, Buffer, g_IniFileName );

    LocalFree( (HLOCAL)Buffer );
    return fRc;
}



/******************************Public*Routine******************************\
* ReadMusicBoxEntry
*
* Try to parse the music box database ini file looking for the given disk
* id.
*
* History:
* dd-mm-94 - StephenE - Created
*
\**************************************************************************/
BOOL
ReadMusicBoxEntry(
    int cdrom,
    DWORD dwId
    )
{
    TCHAR       Section[32];

    TCHAR       s[TITLE_LENGTH];

    int         i;
    PTRACK_INF  temp, curr;

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


    //
    // Try to read in section from ini file.  Note that music box stores
    // the key in decimal NOT hex.
    //

    wsprintf( Section, TEXT("%ld"), dwId );

    GetPrivateProfileString( Section, g_szDiscTitle, g_szNothingThere,
                             g_Devices[ cdrom ]->CdInfo.Title,
                             TITLE_LENGTH, g_szMusicBoxIni );

    //
    // Was the section found?
    //
    if ( _tcscmp(g_Devices[ cdrom ]->CdInfo.Title, g_szNothingThere) == 0 ) {

        //
        // Nope, notify caller
        //

        return FALSE;
    }


    /*
    ** Now read the track information.  Also the artists name is unknown.
    */

    _tcscpy( ARTIST(cdrom), IdStr(STR_UNKNOWN) );

    NUMTRACKS(cdrom) = LASTTRACK(cdrom) - FIRSTTRACK(cdrom) + 1;
    
    // Make sure there is at least one track!!!
    if (0 == NUMTRACKS(cdrom)) {
        return FALSE;
    }

    for ( i = 0, curr = NULL; i < NUMTRACKS(cdrom); i++ ) {

        wsprintf( s, g_szMusicBoxFormat, i + 1 );

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

        GetPrivateProfileString( Section, s, s, temp->name,
                                 TRACK_TITLE_LENGTH, g_szMusicBoxIni );
        temp->TocIndex = i;
        temp->next = NULL;

        if ( curr == NULL ) {

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

            curr->next = temp;
            curr = temp;
        }
    }

    // Make sure there is at least one track in Default playlist!!!
    if (NULL == ALLTRACKS(cdrom)) {
        return FALSE;
    }

    _tcscpy( ARTIST(cdrom), IdStr(STR_UNKNOWN) );


    /*
    ** Process the play list
    */

    GetPrivateProfileString( Section, g_szPlayList, g_szNothingThere,
                             s, TITLE_LENGTH, g_szMusicBoxIni );

    /*
    ** Was the section found?
    */
    if ( _tcscmp(g_Devices[ cdrom ]->CdInfo.Title, g_szNothingThere) == 0 ) {

        /*
        ** Nope, just use the default playlist.
        */

        ResetPlayList( cdrom );

    }
    else {

        LPTSTR      lpPlayList, porder;
        PTRACK_PLAY temp1, prev;
        int         i;
        const       PLAYLEN = 8192;

        lpPlayList = AllocMemory( sizeof(TCHAR) * PLAYLEN );

        GetPrivateProfileString( Section, g_szPlayList, g_szNothingThere,
                                 lpPlayList, PLAYLEN, g_szMusicBoxIni );

        _tcscat( lpPlayList, g_szBlank );
        porder = lpPlayList;
        prev = NULL;

        while ( *porder && (_stscanf( porder, TEXT("%d"),  &i ) == 1) ) {

            i--;

            /*
            ** Assert that i is a valid index.
            **  ie 0 <= i <= (NUMTRACKS(cdrom) - 1)
            */

            i = min( (NUMTRACKS(cdrom) - 1), max( 0, i ) );

            temp1 = (PTRACK_PLAY)AllocMemory( sizeof(TRACK_PLAY) );
            temp1->TocIndex = 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;

            porder = _tcschr( porder, TEXT(' ') ) + 1;
        }

        // Make sure there is at least one track in SAVED playlist!!!
        if (NULL == SAVELIST(cdrom)) {
            // Nope, just use the default playlist instead!!!
            ResetPlayList( cdrom );
        }

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

        LocalFree( (HLOCAL)lpPlayList );
    }

    return TRUE;
}




/*****************************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
    )
{

    DWORD       rc;
    TCHAR       Section[10];
    TCHAR       s[100],s1[100];
    TCHAR       order[ 8192 ];
    TCHAR       torder[ 8192 ];
    int         i;
    LPTSTR      porder;
    int         numtracks, numplay;
    PTRACK_INF  temp, curr;
    PTRACK_PLAY temp1, prev;
    BOOL        OldEntry;
    BOOL        fRewriteEntry = FALSE;


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


    //
    // Try to read in section from ini file
    //

    wsprintf( Section, g_szSectionF, dwId );

    rc = GetPrivateProfileString( Section, g_szTitle, g_szNothingThere,
                                  g_Devices[ cdrom ]->CdInfo.Title,
                                  TITLE_LENGTH, g_IniFileName );

    //
    // Was the section found?
    //

    if ( _tcscmp(g_Devices[ cdrom ]->CdInfo.Title, g_szNothingThere) == 0 ) {

        //
        // Nope, notify caller
        //

        return( FALSE );
    }


    //
    // We found an entry for this disc, so copy all the information
    // from the ini file entry
    //
    // Is this an old entry?
    //

    i = GetPrivateProfileInt( Section, g_szEntryType, 0, g_IniFileName );

    OldEntry = (i==0);

    numtracks = GetPrivateProfileInt( Section, g_szNumTracks,
                                      0, g_IniFileName );

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

    g_Devices[ cdrom ]->CdInfo.NumTracks = numtracks;

    rc = GetPrivateProfileString( Section, g_szArtist, g_szUnknownTxt,
                                  (LPTSTR)ARTIST(cdrom), ARTIST_LENGTH,
                                  g_IniFileName );

    //
    // Validate the stored track numbers
    //
    if (g_Devices[cdrom]->fIsTocValid) {

        int    maxTracks;  // validate the high point in ini file

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

        if (numtracks > maxTracks) {
            // Current ini file 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 < numtracks; i++) {

        temp = (PTRACK_INF)AllocMemory( sizeof(TRACK_INF) );
        temp->TocIndex = i;
        temp->next = NULL;
        wsprintf( s1, IdStr(STR_INIT_TRACK), i + 1 );
        wsprintf( s, TEXT("%d"), i );
        rc = GetPrivateProfileString( Section, s, s1, (LPTSTR)temp->name,
                                      TRACK_TITLE_LENGTH, g_IniFileName );

        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 (OldEntry || fRewriteEntry) {

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

        ResetPlayList( cdrom );

        //
        // Need to rewrite this entry in new format
        //

        WriteEntry( cdrom );

    }
    else {

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

        numplay = GetPrivateProfileInt( Section, g_szNumPlay,
                                        0, g_IniFileName );

        porder = torder;
        ZeroMemory( porder, sizeof(torder) );

        //
        // construct a default play order list
        //

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

            wsprintf( porder, TEXT("%d "), i );
            /* porder += (_tcslen( porder ) * sizeof( TCHAR )); */
            porder += _tcslen( porder );

        }

        rc = GetPrivateProfileString( Section, g_szOrder,
                                      torder, (LPTSTR)order, 8192,
                                      g_IniFileName );

        //
        // Ensure a trailing space
        //

        _tcscat( order, g_szBlank );
        porder = order;
        prev = NULL;

        while ( *porder && (_stscanf( porder, TEXT("%d"),  &i ) == 1) ) {


            /*
            ** Assert that i is a valid index.
            **  ie 0 <= i <= (numtracks - 1)
            */

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

            temp1 = (PTRACK_PLAY)AllocMemory( sizeof(TRACK_PLAY) );
            temp1->TocIndex = 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;

            porder = _tcschr( porder, g_chBlank ) + 1;

        }

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

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

    }

    return TRUE;
}


/******************************Public*Routine******************************\
* WriteSettings
*
*
*
* History:
* 18-11-93 - ricktu - Created
*
\**************************************************************************/
BOOL
WriteSettings(
    VOID
    )
{
    WINDOWPLACEMENT wndpl;
    HKEY            hKey;
    LONG            lRet;
    DWORD           dwTmp;
    extern BOOL     g_fTitlebarShowing;     //cdplayer.c
    extern int      cyMenuCaption;          //cdplayer.c 

    lRet = RegCreateKey( HKEY_CURRENT_USER, g_szRegistryKey, &hKey );
    if ( lRet != ERROR_SUCCESS) {
        return FALSE;
    }


    // Save settings on exit
    dwTmp = (DWORD)g_fSaveOnExit;
    RegSetValueEx( hKey, g_szSaveSettingsOnExit, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    if ( !g_fSaveOnExit ) {

        RegCloseKey( hKey );
        return TRUE;
    }


    // Small LED font
    dwTmp = (DWORD)g_fSmallLedFont;
    RegSetValueEx( hKey, g_szSmallFont, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Enable Tooltips
    dwTmp = (DWORD)g_fToolTips;
    RegSetValueEx( hKey, g_szToolTips, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Stop CD playing on exit
    dwTmp = (DWORD)g_fStopCDOnExit;
    RegSetValueEx( hKey, g_szStopCDPlayingOnExit, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Currect track time
    dwTmp = (DWORD)g_fDisplayT;
    RegSetValueEx( hKey, g_szDisplayT, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Time remaining for this track
    dwTmp = (DWORD)g_fDisplayTr;
    RegSetValueEx( hKey, g_szDisplayTr, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Time remaining for this play list
    dwTmp = (DWORD)g_fDisplayDr;
    RegSetValueEx( hKey, g_szDisplayDr, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Play in selected order
    dwTmp = (DWORD)g_fSelectedOrder;
    RegSetValueEx( hKey, g_szInOrderPlay, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Use single disk
    dwTmp = (DWORD)!g_fSingleDisk;
    RegSetValueEx( hKey, g_szMultiDiscPlay, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Intro play ( Default 10Secs)
    dwTmp = (DWORD)g_fIntroPlay;
    RegSetValueEx( hKey, g_szIntroPlay, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    dwTmp = (DWORD)g_IntroPlayLength;
    RegSetValueEx( hKey, g_szIntroPlayLen, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Continuous play (loop at end)
    dwTmp = (DWORD)g_fContinuous;
    RegSetValueEx( hKey, g_szContinuousPlay, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Show toolbar
    dwTmp = (DWORD)g_fToolbarVisible;
    RegSetValueEx( hKey, g_szToolbar, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Show track information
    dwTmp = (DWORD)g_fTrackInfoVisible;
    RegSetValueEx( hKey, g_szDiscAndTrackDisplay, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Show track status bar
    dwTmp = (DWORD)g_fStatusbarVisible;
    RegSetValueEx( hKey, g_szStatusBar, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );


    // Save window position.
    wndpl.length = sizeof(WINDOWPLACEMENT);
    GetWindowPlacement(g_hwndApp,&wndpl);
    if (!g_fTitlebarShowing) {
        wndpl.rcNormalPosition.top -= cyMenuCaption;
    }

    // X pos
    dwTmp = (DWORD)wndpl.rcNormalPosition.left;
    RegSetValueEx( hKey, g_szWindowOriginX, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    // Y pos
    dwTmp = (DWORD)wndpl.rcNormalPosition.top;
    RegSetValueEx( hKey, g_szWindowOriginY, 0L, REG_DWORD,
                   (LPBYTE)&dwTmp, sizeof(dwTmp) );

    RegCloseKey( hKey );
    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
    )
{

    int         i, num;
    PTRACK_INF  temp, temp1;

    /*
    ** 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;


    /*
    ** Look again in cdplayer.ini.  This time use the original cdplayer key.
    ** If we found the original key in cdplayer.ini write the new key into
    ** cdplayer.ini and then return
    */

    if ( ReadEntry(cdrom, ComputeOrgDiscId(cdrom)) ) {

        /*
        ** If the disc was under an Original id, we need to delete the
        ** old one, convert it to the new format, and save it under
        ** its new key.
        */

        DeleteEntry( ComputeOrgDiscId(cdrom) );
        WriteEntry( cdrom );

    }


    /*
    ** Final look in cdplayer.ini.  This time use the OLD cdplayer key.
    ** If we found the OLD key in cdplayer.ini write the new key into
    ** cdplayer.ini and then return
    */

    else if ( ReadEntry(cdrom, ComputeOldDiscId(cdrom)) ) {

        /*
        ** If the disc was under an OLD id, we need to delete the
        ** old one, convert it to the new format, and save it under
        ** its new key.
        */

        DeleteEntry( ComputeOldDiscId(cdrom) );
        WriteEntry( cdrom );
    }


    /*
    ** Couldn't find it in cdplayer.ini, now look for the key in musicbox.ini
    ** If we found the key in musicbox.ini write it into cdplayer.ini and
    ** then return
    */

    else if ( ReadMusicBoxEntry(cdrom, key) ) {

        WriteEntry( cdrom );
    }


    /*
    ** This is a new entry, fill it in but don't store it in the database.
    */

    else {

        g_Devices[ cdrom ]->CdInfo.IsVirginCd = TRUE;

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

        NUMTRACKS( cdrom ) = num = lpTOC->LastTrack - lpTOC->FirstTrack + 1;


        /*
        ** 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 );
    }
}