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;
}
void retag_set_info(t_uint32 p_subsong, const file_info &p_info, abort_callback &p_abort)
{
ASAPInfo *info = const_cast<ASAPInfo *>(ASAP_GetInfo(asap));
ASAPInfo_SetAuthor(info, empty_if_null(p_info.meta_get("composer", 0)));
ASAPInfo_SetTitle(info, empty_if_null(p_info.meta_get("title", 0)));
ASAPInfo_SetDate(info, empty_if_null(p_info.meta_get("date", 0)));
}
int TrackCount(const char* strFile)
{
void* file = XBMC->OpenFile(strFile, 0);
if (!file)
return 1;
int len = XBMC->GetFileLength(file);
uint8_t* data = new uint8_t[len];
XBMC->ReadFile(file, data, len);
XBMC->CloseFile(file);
ASAP* asap = ASAP_New();
// Now load the module
if (!ASAP_Load(asap, strFile, data, len))
{
ASAP_Delete(asap);
delete[] data;
return 1;
}
delete[] data;
const ASAPInfo* info = ASAP_GetInfo(asap);
int result = ASAPInfo_GetSongs(info);
ASAP_Delete(asap);
return result;
}
int playSong(int song)
{
int duration = getSongDurationInternal(ASAP_GetInfo(asap), song, asap);
ASAP_PlaySong(asap, song, duration); /* FIXME: check errors */
ASAP_MutePokeyChannels(asap, mute_mask);
return duration;
}
static void asap_play_file(char *filename)
{
const ASAPInfo *info;
int song;
int duration;
char *title;
if (asap == NULL)
return;
if (!asap_load_file(filename))
return;
if (!ASAP_Load(asap, filename, module, module_len))
return;
info = ASAP_GetInfo(asap);
song = ASAPInfo_GetDefaultSong(info);
duration = ASAPInfo_GetDuration(info, song);
if (!ASAP_PlaySong(asap, song, duration))
return;
channels = ASAPInfo_GetChannels(info);
if (!mod.output->open_audio(BITS_PER_SAMPLE == 8 ? FMT_U8 : FMT_S16_LE, ASAP_SAMPLE_RATE, channels))
return;
title = asap_get_title(filename, info);
mod.set_info(title, duration, BITS_PER_SAMPLE * 1000, ASAP_SAMPLE_RATE, channels);
g_free(title);
seek_to = -1;
thread_run = TRUE;
generated_eof = FALSE;
pthread_create(&thread_handle, NULL, asap_play_thread, NULL);
}
static int asap_decode(void *data, char *buf, int buf_len, struct sound_params *sound_params)
{
ASAP_Decoder *d = (ASAP_Decoder *) data;
sound_params->channels = ASAPInfo_GetChannels(ASAP_GetInfo(d->asap));
sound_params->rate = ASAP_SAMPLE_RATE;
sound_params->fmt = BITS_PER_SAMPLE == 8 ? SFMT_U8 : (SFMT_S16 | SFMT_LE);
return ASAP_Generate(d->asap, (unsigned char *) buf, buf_len, BITS_PER_SAMPLE == 8 ? ASAPSampleFormat_U8 : ASAPSampleFormat_S16_L_E);
}
static void *asap_open(const char *uri)
{
ASAP_Decoder *d = (ASAP_Decoder *) xmalloc(sizeof(ASAP_Decoder));
if (!asap_load(d, uri) || !ASAP_PlaySong(d->asap, ASAPInfo_GetDefaultSong(ASAP_GetInfo(d->asap)), d->duration)) {
asap_close(d);
return NULL;
}
return d;
}
void retag_commit(abort_callback &p_abort)
{
m_file.release();
filesystem::g_open(m_file, filename, filesystem::open_mode_write_new, p_abort);
this->p_abort = &p_abort;
ByteWriter bw = { this, static_write };
if (!ASAPWriter_Write(filename, bw, ASAP_GetInfo(asap), module, module_len, FALSE))
throw exception_io_unsupported_format();
}
CInputDecoder * __cdecl Open(char *filename, int audioDataOffset)
{
BYTE module[ASAPInfo_MAX_MODULE_LENGTH];
int module_len;
if (!loadModule(filename, module, &module_len))
return NULL;
if (!ASAP_Load(asap, filename, module, module_len))
return NULL;
playSong(ASAPInfo_GetDefaultSong(ASAP_GetInfo(asap)));
return new CASAPDecoder();
}
void* Init(const char* strFile, unsigned int filecache, int* channels,
int* samplerate, int* bitspersample, int64_t* totaltime,
int* bitrate, AEDataFormat* format, const AEChannel** channelinfo)
{
int track=0;
std::string toLoad(strFile);
if (toLoad.find(".asapstream") != std::string::npos)
{
size_t iStart=toLoad.rfind('-') + 1;
track = atoi(toLoad.substr(iStart, toLoad.size()-iStart-11).c_str());
// The directory we are in, is the file
// that contains the bitstream to play,
// so extract it
size_t slash = toLoad.rfind('\\');
if (slash == std::string::npos)
slash = toLoad.rfind('/');
toLoad = toLoad.substr(0, slash);
}
void* file = XBMC->OpenFile(toLoad.c_str(),0);
if (!file)
return NULL;
int len = XBMC->GetFileLength(file);
uint8_t* data = new uint8_t[len];
XBMC->ReadFile(file, data, len);
XBMC->CloseFile(file);
ASAPContext* result = new ASAPContext;
result->asap = ASAP_New();
// Now load the module
if (!ASAP_Load(result->asap, toLoad.c_str(), data, len))
{
delete[] data;
delete result;
}
delete[] data;
const ASAPInfo* info = ASAP_GetInfo(result->asap);
*channels = ASAPInfo_GetChannels(info);
*samplerate = 44100;
*bitspersample = 16;
*totaltime = ASAPInfo_GetDuration(info, track);
*format = AE_FMT_S16NE;
*channelinfo = NULL;
*bitrate = 0;
ASAP_PlaySong(result->asap, track, *totaltime);
return result;
}
void get_info(t_uint32 p_subsong, file_info &p_info, abort_callback &p_abort)
{
int duration = get_song_duration(p_subsong, false);
if (duration >= 0)
p_info.set_length(duration / 1000.0);
const ASAPInfo *info = ASAP_GetInfo(asap);
p_info.info_set_int("channels", ASAPInfo_GetChannels(info));
p_info.info_set_int("subsongs", ASAPInfo_GetSongs(info));
meta_set(p_info, "composer", ASAPInfo_GetAuthor(info));
meta_set(p_info, "title", ASAPInfo_GetTitle(info));
meta_set(p_info, "date", ASAPInfo_GetDate(info));
}
int get_song_duration(int song, bool play)
{
const ASAPInfo *info = ASAP_GetInfo(asap);
int duration = ASAPInfo_GetDuration(info, song);
if (duration < 0) {
if (play)
ASAP_DetectSilence(asap, silence_seconds);
return 1000 * song_length;
}
if (play)
ASAP_DetectSilence(asap, 0);
if (play_loops && ASAPInfo_GetLoop(info, song))
return 1000 * song_length;
return duration;
}
bool decode_run(audio_chunk &p_chunk, abort_callback &p_abort)
{
int channels = ASAPInfo_GetChannels(ASAP_GetInfo(asap));
int buffered_bytes = BUFFERED_BLOCKS * channels * (BITS_PER_SAMPLE / 8);
static BYTE buffer[BUFFERED_BLOCKS * 2 * (BITS_PER_SAMPLE / 8)];
buffered_bytes = ASAP_Generate(asap, buffer, buffered_bytes,
BITS_PER_SAMPLE == 8 ? ASAPSampleFormat_U8 : ASAPSampleFormat_S16_L_E);
if (buffered_bytes == 0)
return false;
p_chunk.set_data_fixedpoint(buffer, buffered_bytes, ASAP_SAMPLE_RATE,
channels, BITS_PER_SAMPLE,
channels == 2 ? audio_chunk::channel_config_stereo : audio_chunk::channel_config_mono);
return true;
}
static DWORD WINAPI playThread(LPVOID dummy)
{
int channels = ASAPInfo_GetChannels(ASAP_GetInfo(asap));
while (thread_run) {
static BYTE buffer[BUFFERED_BLOCKS * 2 * (BITS_PER_SAMPLE / 8)
#if SUPPORT_EQUALIZER
* 2
#endif
];
int buffered_bytes = BUFFERED_BLOCKS * channels * (BITS_PER_SAMPLE / 8);
if (seek_needed >= 0) {
mod.outMod->Flush(seek_needed);
ASAP_Seek(asap, seek_needed);
seek_needed = -1;
}
if (mod.outMod->CanWrite() >= buffered_bytes
#if SUPPORT_EQUALIZER
<< mod.dsp_isactive()
#endif
) {
int t;
buffered_bytes = ASAP_Generate(asap, buffer, buffered_bytes, BITS_PER_SAMPLE == 8 ? ASAPSampleFormat_U8 : ASAPSampleFormat_S16_L_E);
if (buffered_bytes <= 0) {
mod.outMod->CanWrite();
if (!mod.outMod->IsPlaying()) {
PostMessage(mod.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
return 0;
}
Sleep(10);
continue;
}
t = mod.outMod->GetWrittenTime();
mod.SAAddPCMData(buffer, channels, BITS_PER_SAMPLE, t);
mod.VSAAddPCMData(buffer, channels, BITS_PER_SAMPLE, t);
#if SUPPORT_EQUALIZER
t = buffered_bytes / (channels * (BITS_PER_SAMPLE / 8));
t = mod.dsp_dosamples((short *) buffer, t, BITS_PER_SAMPLE, channels, ASAP_SAMPLE_RATE);
t *= channels * (BITS_PER_SAMPLE / 8);
mod.outMod->Write((char *) buffer, t);
#else
mod.outMod->Write((char *) buffer, buffered_bytes);
#endif
}
else
Sleep(20);
}
return 0;
}
static void asap_info(const char *file, struct file_tags *tags, const int tags_sel)
{
ASAP_Decoder d;
if (asap_load(&d, file)) {
if ((tags_sel & TAGS_COMMENTS) != 0) {
const ASAPInfo *info = ASAP_GetInfo(d.asap);
tags->title = xstrdup(ASAPInfo_GetTitleOrFilename(info));
tags->artist = xstrdup(ASAPInfo_GetAuthor(info));
tags->filled |= TAGS_COMMENTS;
}
if ((tags_sel & TAGS_TIME) != 0) {
tags->time = d.duration / 1000;
tags->filled |= TAGS_TIME;
}
}
ASAP_Delete(d.asap);
}
bool ReadTag(const char* strFile, char* title, char* artist,
int* length)
{
int track=1;
std::string toLoad(strFile);
if (toLoad.find(".asapstream") != std::string::npos)
{
size_t iStart=toLoad.rfind('-') + 1;
track = atoi(toLoad.substr(iStart, toLoad.size()-iStart-11).c_str());
// The directory we are in, is the file
// that contains the bitstream to play,
// so extract it
size_t slash = toLoad.rfind('\\');
if (slash == std::string::npos)
slash = toLoad.rfind('/');
toLoad = toLoad.substr(0, slash);
}
void* file = XBMC->OpenFile(toLoad.c_str(), 0);
if (!file)
return false;
int len = XBMC->GetFileLength(file);
uint8_t* data = new uint8_t[len];
XBMC->ReadFile(file, data, len);
XBMC->CloseFile(file);
ASAP* asap = ASAP_New();
// Now load the module
if (!ASAP_Load(asap, strFile, data, len))
{
delete[] data;
return false;
}
delete[] data;
const ASAPInfo* info = ASAP_GetInfo(asap);
strcpy(artist, ASAPInfo_GetAuthor(info));
strcpy(title, ASAPInfo_GetTitleOrFilename(info));
*length = ASAPInfo_GetDuration(info, track);
return true;
}
static cibool asap_load(ASAP_Decoder *d, const char *filename)
{
struct io_stream *s;
ssize_t module_len;
unsigned char *module;
cibool ok;
const ASAPInfo *info;
int song;
int duration;
d->asap = NULL;
decoder_error_init(&d->error);
s = io_open(filename, 0);
if (s == NULL) {
decoder_error(&d->error, ERROR_FATAL, 0, "Can't open %s", filename);
return FALSE;
}
module_len = io_file_size(s);
module = (unsigned char *) xmalloc(module_len);
module_len = io_read(s, module, module_len);
io_close(s);
d->asap = ASAP_New();
if (d->asap == NULL) {
decoder_error(&d->error, ERROR_FATAL, 0, "Out of memory");
return FALSE;
}
ok = ASAP_Load(d->asap, filename, module, module_len);
free(module);
if (!ok) {
decoder_error(&d->error, ERROR_FATAL, 0, "Unsupported file format");
return FALSE;
}
info = ASAP_GetInfo(d->asap);
song = ASAPInfo_GetDefaultSong(info);
duration = ASAPInfo_GetDuration(info, song);
if (duration < 0)
duration = DEFAULT_SONG_LENGTH * 1000;
d->duration = duration;
return TRUE;
}
static void process_file(const char *input_file)
{
FILE *fp;
static unsigned char module[ASAPInfo_MAX_MODULE_LENGTH];
int module_len;
ASAP *asap;
const ASAPInfo *info;
SDL_AudioSpec desired;
fp = fopen(input_file, "rb");
if (fp == NULL)
fatal_error("cannot open %s", input_file);
module_len = fread(module, 1, sizeof(module), fp);
fclose(fp);
asap = ASAP_New();
if (!ASAP_Load(asap, input_file, module, module_len))
fatal_error("%s: unsupported file", input_file);
info = ASAP_GetInfo(asap);
if (song < 0)
song = ASAPInfo_GetDefaultSong(info);
if (!ASAP_PlaySong(asap, song, -1))
fatal_error("%s: PlaySong failed", input_file);
print_header("Name", ASAPInfo_GetTitle(info));
print_header("Author", ASAPInfo_GetAuthor(info));
print_header("Date", ASAPInfo_GetDate(info));
if (SDL_Init(SDL_INIT_AUDIO) != 0)
sdl_error("SDL_Init");
desired.freq = ASAP_SAMPLE_RATE;
desired.format = AUDIO_S16LSB;
desired.channels = ASAPInfo_GetChannels(info);
desired.samples = 4096;
desired.callback = audio_callback;
desired.userdata = asap;
if (SDL_OpenAudio(&desired, NULL) != 0)
sdl_error("SDL_OpenAudio");
SDL_PauseAudio(0);
printf(" playing - press Enter to quit\n");
getchar();
SDL_Quit();
}
static gboolean play_start(InputPlayback *playback, const char *filename, VFSFile *file, int start_time, int stop_time, gboolean pause)
{
int song = -1;
unsigned char module[ASAPInfo_MAX_MODULE_LENGTH];
int module_len;
gboolean ok;
const ASAPInfo *info;
int channels;
#if _AUD_PLUGIN_VERSION >= 10
char *real_filename = filename_split_subtune(filename, &song);
if (real_filename != NULL)
filename = real_filename;
#endif
module_len = load_module(filename, file, module);
ok = module_len > 0 && ASAP_Load(asap, filename, module, module_len);
#if _AUD_PLUGIN_VERSION >= 10
g_free(real_filename);
#endif
if (!ok)
return FALSE;
info = ASAP_GetInfo(asap);
channels = ASAPInfo_GetChannels(info);
if (song > 0)
song--;
else
song = ASAPInfo_GetDefaultSong(info);
if (stop_time < 0)
stop_time = ASAPInfo_GetDuration(info, song);
if (!ASAP_PlaySong(asap, song, stop_time))
return FALSE;
if (start_time > 0)
ASAP_Seek(asap, start_time);
if (!playback->output->open_audio(BITS_PER_SAMPLE == 8 ? FMT_U8 : FMT_S16_LE, ASAP_SAMPLE_RATE, channels))
return FALSE;
playback->set_params(playback,
#if _AUD_PLUGIN_VERSION < 18
NULL, 0,
#endif
0, ASAP_SAMPLE_RATE, channels);
if (pause)
playback->output->pause(TRUE);
playing = TRUE;
playback->set_pb_ready(playback);
for (;;) {
static unsigned char buffer[4096];
int len;
pthread_mutex_lock(&control_mutex);
if (!playing) {
pthread_mutex_unlock(&control_mutex);
break;
}
len = ASAP_Generate(asap, buffer, sizeof(buffer), BITS_PER_SAMPLE == 8 ? ASAPSampleFormat_U8 : ASAPSampleFormat_S16_L_E);
pthread_mutex_unlock(&control_mutex);
if (len <= 0) {
#if _AUD_PLUGIN_VERSION < 18
playback->eof = TRUE;
#endif
break;
}
#if _AUD_PLUGIN_VERSION >= 14
playback->output->write_audio(buffer, len);
#else
playback->pass_audio(playback, BITS_PER_SAMPLE == 8 ? FMT_U8 : FMT_S16_LE, channels, len, buffer, NULL);
#endif
}
#if _AUD_PLUGIN_VERSION_MIN < 40
while (playing && playback->output->buffer_playing())
g_usleep(10000);
#endif
pthread_mutex_lock(&control_mutex);
playing = FALSE;
pthread_mutex_unlock(&control_mutex);
#if _AUD_PLUGIN_VERSION_MIN < 40
playback->output->close_audio();
#endif
return TRUE;
}
t_uint32 get_subsong_count()
{
return ASAPInfo_GetSongs(ASAP_GetInfo(asap));
}
int EMSCRIPTEN_KEEPALIVE asap_getInfo() {
info= ASAP_GetInfo(getAsap());
return 0;
}
