static int play(char *fn)
{
LONGLONG filesize;
DWORD thread_id;
int maxlatency;
/* checks */
if (decoder_ == 0) return 1;
if (!(filesize = FileSize(fn))) return -1;
/* init decoder */
if (!FLAC_plugin__decoder_init(decoder_, fn, filesize, &stream_data_, &flac_cfg.output))
return 1;
strcpy(lastfn_, fn);
/* open output */
maxlatency = mod_.outMod->Open(stream_data_.sample_rate, stream_data_.channels, stream_data_.output_bits_per_sample, -1, -1);
if (maxlatency < 0)
{
FLAC_plugin__decoder_finish(decoder_);
return 1;
}
/* set defaults */
mod_.outMod->SetVolume(-666);
mod_.outMod->SetPan(0);
/* initialize vis stuff */
mod_.SAVSAInit(maxlatency, stream_data_.sample_rate);
mod_.VSASetInfo(stream_data_.sample_rate, stream_data_.channels);
/* set info */
mod_.SetInfo(stream_data_.average_bps, stream_data_.sample_rate/1000, stream_data_.channels, 1);
/* start playing thread */
paused = 0;
thread_handle = CreateThread(NULL, 0, DecodeThread, NULL, 0, &thread_id);
if (!thread_handle) return 1;
return 0;
}
int play(char *fn)
{
int maxlatency;
int thread_id;
if (InitADPFILE(fn, &cubefile) && InitADXFILE(fn, &cubefile) && InitDSPFILE(fn, &cubefile)) return 1;
lstrcpy(lastfn,fn);
paused=0;
decode_pos_ms=0;
seek_needed=-1;
maxlatency = mod.outMod->Open(cubefile.ch[0].sample_rate,cubefile.NCH,BPS, -1,-1);
if (maxlatency < 0) // error opening device
{
MessageBox(NULL, "error opening device", AppName, MB_OK);
return 1;
}
// dividing by 1000 for the first parameter of setinfo makes it
// display 'H'... for hundred.. i.e. 14H Kbps.
mod.SetInfo((cubefile.ch[0].sample_rate*BPS*cubefile.NCH)/1000,cubefile.ch[0].sample_rate/1000,cubefile.NCH,1);
// initialize vis stuff
mod.SAVSAInit(maxlatency,cubefile.ch[0].sample_rate);
mod.VSASetInfo(cubefile.NCH,cubefile.ch[0].sample_rate);
mod.outMod->SetVolume(-666); // set the output plug-ins default volume
killDecodeThread=0;
thread_handle = (HANDLE) CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) DecodeThread,(void *) &killDecodeThread,0,&thread_id);
SetThreadPriority(thread_handle,priarray[CPUPriority]);
return 0;
}
static int play(char *fn)
{
int song;
int maxlatency;
DWORD threadId;
strcpy(current_filename_with_song, fn);
song = extractSongNumber(fn, current_filename);
if (!loadModule(current_filename, module, &module_len))
return -1;
if (!ASAP_Load(&asap, current_filename, module, module_len))
return 1;
if (song < 0)
song = asap.module_info.default_song;
duration = playSong(song);
maxlatency = mod.outMod->Open(ASAP_SAMPLE_RATE, channels, BITS_PER_SAMPLE, -1, -1);
if (maxlatency < 0)
return 1;
mod.SetInfo(BITS_PER_SAMPLE, ASAP_SAMPLE_RATE / 1000, channels, 1);
mod.SAVSAInit(maxlatency, ASAP_SAMPLE_RATE);
// the order of VSASetInfo's arguments in in2.h is wrong!
// http://forums.winamp.com/showthread.php?postid=1841035
mod.VSASetInfo(ASAP_SAMPLE_RATE, channels);
mod.outMod->SetVolume(-666);
seek_needed = -1;
thread_run = TRUE;
thread_handle = CreateThread(NULL, 0, playThread, NULL, 0, &threadId);
if (playing_info)
updateInfoDialog(current_filename, song);
return thread_handle != NULL ? 0 : 1;
}
static int play(char *fn)
{
char filename[MAX_PATH];
int song;
const ASAPInfo *info;
int channels;
int maxlatency;
DWORD threadId;
strcpy(playing_filename_with_song, fn);
song = extractSongNumber(fn, filename);
if (!loadModule(filename, module, &module_len))
return -1;
if (!ASAP_Load(asap, filename, module, module_len))
return 1;
info = ASAP_GetInfo(asap);
if (song < 0)
song = ASAPInfo_GetDefaultSong(info);
duration = playSong(song);
channels = ASAPInfo_GetChannels(info);
maxlatency = mod.outMod->Open(ASAP_SAMPLE_RATE, channels, BITS_PER_SAMPLE, -1, -1);
if (maxlatency < 0)
return 1;
mod.SetInfo(BITS_PER_SAMPLE, ASAP_SAMPLE_RATE / 1000, channels, 1);
mod.SAVSAInit(maxlatency, ASAP_SAMPLE_RATE);
// the order of VSASetInfo's arguments in in2.h is wrong!
// http://forums.winamp.com/showthread.php?postid=1841035
mod.VSASetInfo(ASAP_SAMPLE_RATE, channels);
mod.outMod->SetVolume(-666);
seek_needed = -1;
thread_run = TRUE;
thread_handle = CreateThread(NULL, 0, playThread, NULL, 0, &threadId);
setPlayingSong(filename, song);
return thread_handle != NULL ? 0 : 1;
}
int play(char *fn)
{
int maxlatency;
int thread_id;
input_file = CreateFile(fn,GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,
OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
if (input_file == INVALID_HANDLE_VALUE) // error opening file
{
return 1;
}
file_length=GetFileSize(input_file,NULL);
if(IsCurrentFile)
{
if(!strcmp(fn,lastfn))
{
IsCurrentFile = TRUE;
SongChanged=FALSE;
}
else
{
IsCurrentFile = FALSE;
SongChanged=TRUE;
}
}
strcpy(lastfn,fn);
paused=0;
decode_pos_ms=0;
seek_needed=-1;
GSFRun(fn);
maxlatency = mod.outMod->Open(sndSamplesPerSec,sndNumChannels,sndBitsPerSample, -1,-1);
if (maxlatency < 0) // error opening device
{
CloseHandle(input_file);
input_file=INVALID_HANDLE_VALUE;
return 1;
}
// dividing by 1000 for the first parameter of setinfo makes it
// display 'H'... for hundred.. i.e. 14H Kbps.
mod.SetInfo((sndSamplesPerSec*sndBitsPerSample*sndNumChannels)/1000,sndSamplesPerSec/1000,sndNumChannels,1);
// initialize vis stuff
mod.SAVSAInit(maxlatency,sndSamplesPerSec);
mod.VSASetInfo(sndSamplesPerSec,sndNumChannels);
mod.outMod->SetVolume(-666); // set the output plug-ins default volume
killDecodeThread=0;
thread_handle = (HANDLE) CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) DecodeThread,(void *) &killDecodeThread,0,&thread_id);
return 0;
}
static DWORD WINAPI DecodeThread(void *unused)
{
const unsigned channels = stream_data_.channels;
const unsigned bits_per_sample = stream_data_.bits_per_sample;
const unsigned target_bps = stream_data_.output_bits_per_sample;
const unsigned sample_rate = stream_data_.sample_rate;
const unsigned fact = channels * (target_bps/8);
while (stream_data_.is_playing)
{
/* seek needed */
if (stream_data_.seek_to != -1)
{
const int pos = FLAC_plugin__seek(decoder_, &stream_data_);
if (pos != -1) mod_.outMod->Flush(pos);
}
/* stream ended */
else if (stream_data_.eof)
{
if (!mod_.outMod->IsPlaying())
{
PostMessage(mod_.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
return 0;
}
Sleep(10);
}
/* decode */
else
{
/* decode samples */
int bytes = FLAC_plugin__decode(decoder_, &stream_data_, sample_buffer_);
const int n = bytes / fact;
/* visualization */
do_vis(sample_buffer_, channels, target_bps, mod_.outMod->GetWrittenTime(), n);
/* dsp */
if (mod_.dsp_isactive())
bytes = mod_.dsp_dosamples((short*)sample_buffer_, n, target_bps, channels, sample_rate) * fact;
/* output */
while (mod_.outMod->CanWrite()<bytes && stream_data_.is_playing && stream_data_.seek_to==-1)
Sleep(20);
if (stream_data_.is_playing && stream_data_.seek_to==-1)
mod_.outMod->Write(sample_buffer_, bytes);
/* show bitrate */
if (flac_cfg.display.show_bps)
{
const int rate = FLAC_plugin__get_rate(mod_.outMod->GetWrittenTime(), mod_.outMod->GetOutputTime(), &stream_data_);
if (rate) mod_.SetInfo(rate/1000, stream_data_.sample_rate/1000, stream_data_.channels, 1);
}
}
}
return 0;
}
int play(char *fn)
{
int maxlatency;
int thread_id;
HANDLE input_file = INVALID_HANDLE_VALUE;
unsigned output_bits_per_sample;
if(0 == decoder_) {
return 1;
}
input_file = CreateFile(fn, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(input_file == INVALID_HANDLE_VALUE) {
return -1;
}
CloseHandle(input_file);
if(!safe_decoder_init_(fn, decoder_)) {
return 1;
}
#ifdef FLAC__DO_DITHER
output_bits_per_sample = min(file_info_.bits_per_sample, 16);
#else
output_bits_per_sample = file_info_.bits_per_sample;
#endif
strcpy(lastfn_, fn);
paused_ = 0;
decode_pos_ms_ = 0;
seek_needed_ = -1;
wide_samples_in_reservoir_ = 0;
maxlatency = mod_.outMod->Open(file_info_.sample_rate, file_info_.channels, output_bits_per_sample, -1, -1);
if(maxlatency < 0) { /* error opening device */
return 1;
}
/* dividing by 1000 for the first parameter of setinfo makes it */
/* display 'H'... for hundred.. i.e. 14H Kbps. */
mod_.SetInfo((file_info_.sample_rate*file_info_.bits_per_sample*file_info_.channels)/1000, file_info_.sample_rate/1000, file_info_.channels, 1);
/* initialize vis stuff */
mod_.SAVSAInit(maxlatency, file_info_.sample_rate);
mod_.VSASetInfo(file_info_.sample_rate, file_info_.channels);
mod_.outMod->SetVolume(-666); /* set the output plug-ins default volume */
killDecodeThread = 0;
thread_handle = (HANDLE) CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) DecodeThread, (void *) &killDecodeThread, 0, &thread_id);
return 0;
}
static int play( const in_char * fn ) {
if ( !fn ) {
return -1;
}
try {
std::ifstream s( fn, std::ios::binary );
std::map< std::string, std::string > ctls;
ctls["seek.sync_samples"] = "1";
self->mod = new openmpt::module( s, std::clog, ctls );
self->cached_filename = fn;
self->cached_title = StringDecode( self->mod->get_metadata( "title" ), CP_UTF8 );
self->cached_length = static_cast<int>( self->mod->get_duration_seconds() * 1000.0 );
self->cached_infotext = generate_infotext( self->cached_filename, *self->mod );
apply_options();
self->samplerate = self->settings.samplerate;
self->channels = self->settings.channels;
int maxlatency = inmod.outMod->Open( self->samplerate, self->channels, BPS, -1, -1 );
std::ostringstream str;
str << maxlatency;
inmod.SetInfo( self->mod->get_num_channels(), self->samplerate/1000, self->channels, 1 );
inmod.SAVSAInit( maxlatency, self->samplerate );
inmod.VSASetInfo( self->channels, self->samplerate );
inmod.outMod->SetVolume( -666 );
inmod.outMod->SetPan( 0 );
self->paused = false;
self->decode_position_frames = 0;
self->PlayThread = CreateThread( NULL, 0, DecodeThread, NULL, 0, &self->PlayThreadID );
return 0;
} catch ( ... ) {
if ( self->mod ) {
delete self->mod;
self->mod = 0;
}
return -1;
}
}
DWORD WINAPI PlayThread(void *b)
{
int done=0;
int l;
int decoded_frames=0;
int br_calc_frames=0;
int br_bytes_consumed=0;
unsigned long bytesconsumed;
PlayThreadAlive = 1;
last_frame = 0;
while (! *((int *)b) )
{
if (seek_needed != -1)
{
int seconds;
// Round off to a second
seconds = seek_needed - (seek_needed%1000);
mod.outMod->Flush(decode_pos_ms);
aac_seek(seconds, seek_table);
decode_pos_ms = seconds;
seek_needed = -1;
decoded_frames = 0;
br_calc_frames = 0;
br_bytes_consumed = 0;
}
if (done)
{
mod.outMod->CanWrite();
if (!mod.outMod->IsPlaying())
{
PostMessage(mod.hMainWindow,WM_WA_AAC_EOF,0,0);
PlayThreadAlive = 0;
return 0;
}
Sleep(10);
}
//assume that max channels is 2.
else if (mod.outMod->CanWrite() >= ((1024*file_info.channels*sizeof(short))<<(mod.dsp_isactive()?1:0)))
{
if(last_frame)
{
done=1;
}
else
{
if (current_file_mode)
bytesconsumed = PlayThread_memmap();
else
bytesconsumed = PlayThread_file();
decoded_frames++;
br_calc_frames++;
br_bytes_consumed += bytesconsumed;
/* Update the variable bitrate about every second */
if(m_variable_bitrate_display && br_calc_frames == 43)
{
int br;
br = (int)((br_bytes_consumed * 8) / (decoded_frames / 43.07));
mod.SetInfo(br/1000, file_info.sampling_rate/1000, file_info.channels, 1);
br_calc_frames = 0;
}
if (!killPlayThread && (frameInfo.samples > 0))
{
mod.SAAddPCMData(sample_buffer,file_info.channels, 16, decode_pos_ms);
mod.VSAAddPCMData(sample_buffer,file_info.channels, 16, decode_pos_ms);
decode_pos_ms+=(1024*1000)/file_info.sampling_rate;
if (mod.dsp_isactive())
l=mod.dsp_dosamples((short *)sample_buffer,frameInfo.samples*sizeof(short)/file_info.channels/(16/8),16,file_info.channels,file_info.sampling_rate)*(file_info.channels*(16/8));
else
l = frameInfo.samples*sizeof(short);
mod.outMod->Write(sample_buffer, l);
}
}
}
else
{
Sleep(10);
}
}
if(seek_table)
{
free(seek_table);
seek_table = NULL;
seek_table_length = 0;
}
PlayThreadAlive = 0;
return 0;
}
int play(char *fn)
{
int maxlatency;
int thread_id;
current_file_mode = m_memmap_file;
if (current_file_mode) {
if (play_memmap(fn))
return -1;
} else {
if (play_file(fn))
return -1;
}
if(seek_table)
{
free(seek_table);
seek_table = NULL;
seek_table_length = 0;
}
get_AAC_format(fn, &file_info, &seek_table, &seek_table_length, 0);
if(infile->http)
{
/* No seeking in http streams */
mod.is_seekable = 0;
}
else
{
if (file_info.headertype == 2) /* ADTS header - seekable */
mod.is_seekable = 1;
else
mod.is_seekable = 0; /* ADIF or Headerless - not seekable */
}
strcpy(lastfn,fn);
paused=0;
decode_pos_ms=0;
seek_needed=-1;
/*
To RageAmp: This is really needed, because aacinfo isn't very accurate on ADIF files yet.
Can be fixed though :-)
*/
file_info.sampling_rate = samplerate;
file_info.channels = frameInfo.channels;
maxlatency = mod.outMod->Open(file_info.sampling_rate, file_info.channels, 16, -1,-1);
if (maxlatency < 0) // error opening device
{
return -1;
}
// initialize vis stuff
mod.SAVSAInit(maxlatency, file_info.sampling_rate);
mod.VSASetInfo(file_info.sampling_rate, file_info.channels);
mod.SetInfo(file_info.bitrate/1000, file_info.sampling_rate/1000, file_info.channels,1);
mod.outMod->SetVolume(-666); // set the output plug-ins default volume
killPlayThread = 0;
if((play_thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) PlayThread, (void *) &killPlayThread, 0, &thread_id)) == NULL)
{
MessageBox(mod.hMainWindow, "Fatal error: Cannot create playback thread\n", "FAAD Error", MB_OK);
return -1;
}
// Note: This line seriously slows down start up time
if(m_priority != 3) // if the priority in config window is set to normal, there is nothing to reset!
SetThreadPriority(play_thread_handle, priority_table[m_priority]);
return 0;
}
// called when winamp wants to play a file
int play(const char *fn)
{
int maxlatency;
int thread_id;
paused=0;
decode_pos_ms=0;
seek_needed=-1;
// CHANGEME! Write your own file opening code here
input_file = CreateFile(fn,GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,
OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
if (input_file == INVALID_HANDLE_VALUE) // error opening file
{
// we return error. 1 means to keep going in the playlist, -1
// means to stop the playlist.
return 1;
}
file_length=GetFileSize(input_file,NULL);
strcpy(lastfn,fn);
// -1 and -1 are to specify buffer and prebuffer lengths.
// -1 means to use the default, which all input plug-ins should
// really do.
maxlatency = mod.outMod->Open(SAMPLERATE,NCH,BPS, -1,-1);
// maxlatency is the maxium latency between a outMod->Write() call and
// when you hear those samples. In ms. Used primarily by the visualization
// system.
if (maxlatency < 0) // error opening device
{
CloseHandle(input_file);
input_file=INVALID_HANDLE_VALUE;
return 1;
}
// dividing by 1000 for the first parameter of setinfo makes it
// display 'H'... for hundred.. i.e. 14H Kbps.
mod.SetInfo((SAMPLERATE*BPS*NCH)/1000,SAMPLERATE/1000,NCH,1);
// initialize visualization stuff
mod.SAVSAInit(maxlatency,SAMPLERATE);
mod.VSASetInfo(SAMPLERATE,NCH);
// set the output plug-ins default volume.
// volume is 0-255, -666 is a token for
// current volume.
mod.outMod->SetVolume(-666);
// launch decode thread
killDecodeThread=0;
thread_handle = (HANDLE)
CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) DecodeThread,NULL,0,&thread_id);
return 0;
}
