bool SdlAudioCDManager::play(int track, int numLoops, int startFrame, int duration, bool onlyEmulate) {
// Prefer emulation
if (DefaultAudioCDManager::play(track, numLoops, startFrame, duration, onlyEmulate))
return true;
// If we're set to only emulate, or have no CD, return here
if (onlyEmulate || !_cdrom)
return false;
if (!numLoops && !startFrame)
return false;
// FIXME: Explain this.
if (duration > 0)
duration += 5;
_cdTrack = track;
_cdNumLoops = numLoops;
_cdStartFrame = startFrame;
SDL_CDStatus(_cdrom);
if (startFrame == 0 && duration == 0)
SDL_CDPlayTracks(_cdrom, track, 0, 1, 0);
else
SDL_CDPlayTracks(_cdrom, track, startFrame, 0, duration);
_cdDuration = duration;
_cdStopTime = 0;
_cdEndTime = SDL_GetTicks() + _cdrom->track[track].length * 1000 / CD_FPS;
return true;
}
void OSystem_SDL::updateCD() {
if (!_cdrom)
return;
if (_cdStopTime != 0 && SDL_GetTicks() >= _cdStopTime) {
SDL_CDStop(_cdrom);
_cdNumLoops = 0;
_cdStopTime = 0;
return;
}
if (_cdNumLoops == 0 || SDL_GetTicks() < _cdEndTime)
return;
if (_cdNumLoops != 1 && SDL_CDStatus(_cdrom) != CD_STOPPED) {
// Wait another second for it to be done
_cdEndTime += 1000;
return;
}
if (_cdNumLoops > 0)
_cdNumLoops--;
if (_cdNumLoops != 0) {
if (_cdStartFrame == 0 && _cdDuration == 0)
SDL_CDPlayTracks(_cdrom, _cdTrack, 0, 1, 0);
else
SDL_CDPlayTracks(_cdrom, _cdTrack, _cdStartFrame, 0, _cdDuration);
_cdEndTime = SDL_GetTicks() + _cdrom->track[_cdTrack].length * 1000 / CD_FPS;
}
}
void ONScripter::playCDAudio()
{
if ( cdaudio_flag ){
#ifdef USE_CDROM
if ( cdrom_info ){
int length = cdrom_info->track[current_cd_track - 1].length / 75;
SDL_CDPlayTracks( cdrom_info, current_cd_track - 1, 0, 1, 0 );
timer_cdaudio_id = SDL_AddTimer( length * 1000, cdaudioCallback, NULL );
}
#endif
}
else{
char filename[256];
sprintf( filename, "cd\\track%2.2d.mp3", current_cd_track );
int ret = playSound( filename, SOUND_MUSIC, cd_play_loop_flag );
if (ret == SOUND_MUSIC) return;
sprintf( filename, "cd\\track%2.2d.ogg", current_cd_track );
ret = playSound( filename, SOUND_MUSIC, cd_play_loop_flag );
if (ret == SOUND_MUSIC) return;
sprintf( filename, "cd\\track%2.2d.wav", current_cd_track );
ret = playSound( filename, SOUND_MUSIC|SOUND_CHUNK, cd_play_loop_flag, MIX_BGM_CHANNEL );
}
}
int cd_playtrack(int trackno)
{
int track;
//added on 01/03/99 by Matt Mueller
if (nocdaudio) return 0;
//end addition -MM
if(trackno > MAX_TRACKS || trackno < 0)
return 0;
track = playlist[trackno];
#ifdef __DJGPP__
if(bcd_play_track(&track))
#elif defined __SDL__
if(CD_INDRIVE(SDL_CDStatus(cdrom)) && !SDL_CDPlayTracks(cdrom,track,0,1,0))
#else
if(0)
#endif
cd_playing = 1;
else
cd_playing = 0;
cd_used = 1;
return cd_playing;
}
//------------------------------------------------------------------------------
bool UnixRedBookDevice::play(U32 track)
{
#if !defined(__FreeBSD__)
if(!mAcquired)
{
setLastError("Device has not been acquired");
return(false);
}
U32 numTracks;
if(!getTrackCount(&numTracks))
return(false);
if(track >= numTracks)
{
setLastError("Track index is out of range");
return(false);
}
if (!updateStatus())
return false;
AssertFatal(mCD, "mCD is NULL");
if (SDL_CDPlayTracks(mCD, track, 0, 1, 0) == -1)
{
setLastError(SDL_GetError());
return false;
}
mPlaying = true;
setLastError("");
return(true);
#endif // !defined(__FreeBSD__)
}
int RBAPlayTrack(int a)
{
if (!initialised) return -1;
if (CD_INDRIVE(SDL_CDStatus(s_cd)) ) {
SDL_CDPlayTracks(s_cd, a-1, 0, 0, 0);
}
return a;
}
static PyObject*
_cd_playtracks (PyObject *self, PyObject *args, PyObject *kwds)
{
int start_track = 0, start = 0, ntracks = 0, length = 0;
PyObject *asfps = Py_False;
int istrue;
SDL_CD *cd = ((PyCD*)self)->cd;
static char *kwlist[] = { "starttrack", "ntracks", "start", "length",
"asfps", NULL };
ASSERT_CDROM_OPEN(self, NULL);
if (!PyArg_ParseTupleAndKeywords (args, kwds, "|iiiiO:play_tracks", kwlist,
&start_track, &ntracks, &start, &length, asfps))
return NULL;
if (start_track < 0 || start_track > cd->numtracks)
{
PyErr_SetString (PyExc_ValueError, "invalid start track");
return NULL;
}
if (ntracks < 0 || ntracks > cd->numtracks - start_track)
{
PyErr_SetString (PyExc_ValueError, "invalid track amount");
return NULL;
}
if (start < 0 || length < 0)
{
PyErr_SetString (PyExc_ValueError,
"start and length must not be negative");
return NULL;
}
istrue = PyObject_IsTrue (asfps);
if (istrue == -1)
return NULL;
if (istrue == 0)
{
/* Start and length are in seconds */
start *= CD_FPS;
length *= CD_FPS;
}
SDL_CDStatus (cd);
if (SDL_CDPlayTracks (cd, start_track, start, ntracks, length) == -1)
{
PyErr_SetString (PyExc_PyGameError, SDL_GetError ());
return NULL;
}
Py_RETURN_NONE;
}
int RBAPlayTrack(int a)
{
if (!s_cd) return -1;
if (CD_INDRIVE(SDL_CDStatus(s_cd)) ) {
if (SDL_CDPlayTracks(s_cd, a-1, 0, 0, 0) == 0)
return a;
}
return -1;
}
// plays tracks first through last, inclusive
int RBAPlayTracks(int first, int last)
{
if (!initialised)
return 0;
if (!CD_INDRIVE(SDL_CDStatus(s_cd)))
return 0;
if (0 > SDL_CDPlayTracks(s_cd, first - 1, 0, last - first + 1, 0))
return 0;
return 1;
}
// plays tracks first through last, inclusive
int RBAPlayTracks(int first, int last, void (*hook_finished)(void))
{
if (!s_cd)
return 0;
if (CD_INDRIVE(SDL_CDStatus(s_cd)))
{
redbook_finished_hook = hook_finished;
return SDL_CDPlayTracks(s_cd, first - 1, 0, last - first + 1, 0) == 0;
}
return 0;
}
void I_PlayCD (UINT8 track, UINT8 looping)
{
#ifdef NOSDLCD
(void)track;
(void)looping;
#else
if (!cdrom || !cdEnabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = cdRemap[track];
if (track < 1 || track > maxTrack)
{
CONS_Printf("I_PlayCD: Bad track number %u.\n", track);
return;
}
// don't try to play a non-audio track
if (cdrom->track[track].type == SDL_DATA_TRACK)
{
CONS_Printf("I_PlayCD: track %u is not audio\n", track);
return;
}
if (cdPlaying)
{
if (playTrack == track)
return;
I_StopCD();
}
if (SDL_CDPlayTracks(cdrom, track, 0, 1, 0))
{
CONS_Printf("Error playing track %d: %s\n",
track, SDL_GetError());
return;
}
playLooping = looping;
playTrack = (Uint8)track;
cdPlaying = true;
if (cd_volume.value == 0)
I_PauseCD();
#endif
}
void I_PlayCD(int track, bool looping)
{
if (cdrom == NULL || !enabled)
return;
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
return;
}
track = cdRemap[track];
if (track < 1 || track > maxTrack)
{
CONS_Printf("I_PlayCD: Bad track number %u.\n", track);
return;
}
// don't try to play a non-audio track
if (cdrom->track[track].type == SDL_DATA_TRACK)
{
CONS_Printf("I_PlayCD: track %i is not audio\n", track);
return;
}
if (playing)
{
if (playTrack == track)
return;
I_StopCD();
}
if (SDL_CDPlayTracks(cdrom, track, 0, 1, 0))
{
CONS_Printf("Error playing track %d: %s\n",
track, SDL_GetError());
return;
}
playLooping = looping;
playTrack = track;
playing = true;
if (cd_volume.value == 0)
{
I_PauseCD();
}
}
void SdlAudioCDManager::playCD(int track, int num_loops, int start_frame, int duration) {
if (!num_loops && !start_frame)
return;
if (!_cdrom)
return;
if (duration > 0)
duration += 5;
_cdTrack = track;
_cdNumLoops = num_loops;
_cdStartFrame = start_frame;
SDL_CDStatus(_cdrom);
if (start_frame == 0 && duration == 0)
SDL_CDPlayTracks(_cdrom, track, 0, 1, 0);
else
SDL_CDPlayTracks(_cdrom, track, start_frame, 0, duration);
_cdDuration = duration;
_cdStopTime = 0;
_cdEndTime = SDL_GetTicks() + _cdrom->track[track].length * 1000 / CD_FPS;
}
static int modcd_playtracks( INSTANCE * my, int * params )
{
if ( params[0] < 0 || params[0] >= SDL_CDNumDrives() ) return 0;
if ( sdl_cd == NULL || sdl_cdnum != params[0] )
{
if ( sdl_cd ) SDL_CDClose( sdl_cd );
sdl_cd = SDL_CDOpen( params[0] );
if ( sdl_cd == NULL ) return 0;
sdl_cdnum = params[0];
}
if ( CD_INDRIVE( SDL_CDStatus( sdl_cd ) ) )
return !SDL_CDPlayTracks( sdl_cd, params[1], 0, params[2], 0 );
return 0;
}
int I_CDMusPlay(int track)
{
int result;
if (cd_handle == NULL)
{
cd_Error = 1;
return -1;
}
// Play one track
// Track is indexed from 1.
result = SDL_CDPlayTracks(cd_handle, track - 1, 0, 1, 0);
cd_Error = 0;
return result;
}
void SoundManager::StartMusic(const sint32 &InTrackNum)
{
m_stopRedbookTemporarily = FALSE;
if (!g_theProfileDB->IsUseRedbookAudio() || !c3files_HasCD()) return;
if (m_noSound) return;
if (m_usePlaySound) return;
if (m_curTrack == -1) return;
#if defined(USE_SDL)
if (!m_cdrom) {
return;
}
CDstatus status = SDL_CDStatus(m_cdrom);
if ((CD_ERROR == status) || (!CD_INDRIVE(status))) {
return;
}
sint32 const numTracks = m_cdrom->numtracks;
#else
if (!m_redbook) {
return;
}
U32 status = AIL_redbook_status(m_redbook);
if (status == REDBOOK_ERROR) {
return;
}
if (AIL_redbook_track(m_redbook)) {
AIL_redbook_stop(m_redbook);
}
sint32 const numTracks = AIL_redbook_tracks(m_redbook);
#endif
if (numTracks <= s_startTrack) return;
m_numTracks = numTracks;
sint32 trackNum = InTrackNum;
if (trackNum < 0) trackNum = 0;
if (trackNum > m_numTracks) trackNum = m_numTracks;
m_curTrack = trackNum;
#if defined(USE_SDL)
SDL_CDPlayTracks(m_cdrom, trackNum, 0, 1, 0);
#else
U32 start;
U32 end;
AIL_redbook_track_info(m_redbook, trackNum, &start, &end);
// Why?
TerminateAllSounds();
AIL_redbook_play(m_redbook, start, end);
#endif
}
static PyObject*
cd_play (PyObject* self, PyObject* args)
{
int cd_id = PyCD_AsID (self);
SDL_CD* cdrom = cdrom_drivedata[cd_id];
int result, track, startframe, numframes, playforever=0;
float start=0.0f, end=0.0f;
PyObject *endobject=NULL;
if (!PyArg_ParseTuple (args, "i|fO", &track, &start, &endobject)) {
return NULL;
}
if (endobject == Py_None) {
playforever = 1;
}
else if (!PyArg_ParseTuple (args, "i|ff", &track, &start, &end)) {
return NULL;
}
CDROM_INIT_CHECK ();
if (!cdrom) {
return RAISE (PyExc_SDLError, "CD drive not initialized");
}
SDL_CDStatus (cdrom);
if (track < 0 || track >= cdrom->numtracks) {
return RAISE (PyExc_IndexError, "Invalid track number");
}
if (cdrom->track[track].type != SDL_AUDIO_TRACK) {
return RAISE (PyExc_SDLError, "CD track type is not audio");
}
/*validate times*/
if (playforever) {
end = start;
}
else if (start == end && start != 0.0f) {
Py_RETURN_NONE;
}
startframe = (int)(start * CD_FPS);
numframes = 0;
if (startframe < 0) {
startframe = 0;
}
if (end) {
numframes = (int) ((end-start) * CD_FPS);
}
else {
numframes = cdrom->track[track].length - startframe;
}
if (numframes < 0 ||
startframe > (int) (cdrom->track[track].length * CD_FPS)) {
Py_RETURN_NONE;
}
result = SDL_CDPlayTracks (cdrom, track, startframe, 0, numframes);
if (result == -1) {
return RAISE (PyExc_SDLError, SDL_GetError ());
}
Py_RETURN_NONE;
}
int main(int argc, char *argv[])
{
int drive;
int i;
SDL_CD *cdrom;
/* Initialize SDL first */
if ( SDL_Init(SDL_INIT_CDROM) < 0 ) {
fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
return(1);
}
/* Find out how many CD-ROM drives are connected to the system */
if ( SDL_CDNumDrives() == 0 ) {
printf("No CD-ROM devices detected\n");
quit(0);
}
printf("Drives available: %d\n", SDL_CDNumDrives());
for ( i=0; i<SDL_CDNumDrives(); ++i ) {
printf("Drive %d: \"%s\"\n", i, SDL_CDName(i));
}
/* Open the CD-ROM */
drive = 0;
i=1;
if ( argv[i] && isdigit(argv[i][0]) ) {
drive = atoi(argv[i++]);
}
cdrom = SDL_CDOpen(drive);
if ( cdrom == NULL ) {
fprintf(stderr, "Couldn't open drive %d: %s\n", drive,
SDL_GetError());
quit(2);
}
#ifdef TEST_NULLCD
cdrom = NULL;
#endif
/* Find out which function to perform */
for ( ; argv[i]; ++i ) {
if ( strcmp(argv[i], "-status") == 0 ) {
/* PrintStatus(drive, cdrom); */
} else
if ( strcmp(argv[i], "-list") == 0 ) {
ListTracks(cdrom);
} else
if ( strcmp(argv[i], "-play") == 0 ) {
int strack, sframe;
int ntrack, nframe;
strack = 0;
if ( argv[i+1] && isdigit(argv[i+1][0]) ) {
strack = atoi(argv[++i]);
}
sframe = 0;
if ( argv[i+1] && isdigit(argv[i+1][0]) ) {
sframe = atoi(argv[++i]);
}
ntrack = 0;
if ( argv[i+1] && isdigit(argv[i+1][0]) ) {
ntrack = atoi(argv[++i]);
}
nframe = 0;
if ( argv[i+1] && isdigit(argv[i+1][0]) ) {
nframe = atoi(argv[++i]);
}
if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) {
if ( SDL_CDPlayTracks(cdrom, strack, sframe,
ntrack, nframe) < 0 ) {
fprintf(stderr,
"Couldn't play tracks %d/%d for %d/%d: %s\n",
strack, sframe, ntrack, nframe, SDL_GetError());
}
} else {
fprintf(stderr, "No CD in drive!\n");
}
} else
if ( strcmp(argv[i], "-pause") == 0 ) {
if ( SDL_CDPause(cdrom) < 0 ) {
fprintf(stderr, "Couldn't pause CD: %s\n",
SDL_GetError());
}
} else
if ( strcmp(argv[i], "-resume") == 0 ) {
if ( SDL_CDResume(cdrom) < 0 ) {
fprintf(stderr, "Couldn't resume CD: %s\n",
SDL_GetError());
}
} else
if ( strcmp(argv[i], "-stop") == 0 ) {
if ( SDL_CDStop(cdrom) < 0 ) {
fprintf(stderr, "Couldn't eject CD: %s\n",
SDL_GetError());
}
} else
if ( strcmp(argv[i], "-eject") == 0 ) {
if ( SDL_CDEject(cdrom) < 0 ) {
fprintf(stderr, "Couldn't eject CD: %s\n",
SDL_GetError());
}
} else
if ( (strcmp(argv[i], "-sleep") == 0) &&
(argv[i+1] && isdigit(argv[i+1][0])) ) {
SDL_Delay(atoi(argv[++i]));
printf("Delayed %d milliseconds\n", atoi(argv[i]));
} else {
PrintUsage(argv[0]);
SDL_CDClose(cdrom);
quit(1);
}
}
PrintStatus(drive, cdrom);
SDL_CDClose(cdrom);
SDL_Quit();
return(0);
}
int CDAudio_SysPlay (int track)
{
return SDL_CDPlayTracks(cd, track-1, 0, 1, 0);
}
