able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/media/cdplayer/database.c

1283 lines
29 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/******************************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 );
}
}
Reference in a new issue Copy permalink