mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1282 lines
29 KiB
1282 lines
29 KiB
/******************************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 );
|
|
}
|
|
}
|