/******************************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 #include "playres.h" #include "cdapi.h" #include "cdplayer.h" #include "database.h" #include "literals.h" #include #include #include #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 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 ); } } 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; } } } if (!g_fSelectedOrder) { ComputeSingleShufflePlayList(cdrom); } RecomputePlayTimes(cdrom); } 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 ); if (!g_fSelectedOrder) { ComputeSingleShufflePlayList(cdrom); } RecomputePlayTimes(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), 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); }