static DB_playItem_t *
cdumb_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
const char *ext = strrchr (fname, '.');
if (ext) {
ext++;
}
else {
ext = "";
}
int is_it;
int is_dos;
int is_ptcompat;
const char *ftype = NULL;
DUH* duh = g_open_module(fname, &is_it, &is_dos, &is_ptcompat, 0, &ftype);
if (!duh) {
return NULL;
}
DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
DUMB_IT_SIGDATA * itsd = duh_get_it_sigdata(duh);
read_metadata_internal (it, itsd);
dumb_it_do_initial_runthrough (duh);
deadbeef->plt_set_item_duration (plt, it, duh_get_length (duh)/65536.0f);
deadbeef->pl_add_meta (it, ":FILETYPE", ftype);
// printf ("duration: %f\n", _info->duration);
after = deadbeef->plt_insert_item (plt, after, it);
deadbeef->pl_item_unref (it);
unload_duh (duh);
return after;
}
int get_length_ms()
{
if (tune == NULL)
return 0;
// duh_get_length represents time as 65536ths of a second
return (duh_get_length(tune) * 10) / 655;
}
int dumb_source_init(audio_source *src, const char* file, int channels, int freq, int resampler) {
dumb_source *local = malloc(sizeof(dumb_source));
// Load file and initialize renderer
char *ext = strrchr(file, '.') + 1;
if(strcasecmp(ext, "psm") == 0) {
local->data = dumb_load_psm(file, 0);
} else if(strcasecmp(ext, "s3m") == 0) {
local->data = dumb_load_s3m(file);
} else if(strcasecmp(ext, "mod") == 0) {
local->data = dumb_load_mod(file, 0);
} else if(strcasecmp(ext, "it") == 0) {
local->data = dumb_load_it(file);
} else if(strcasecmp(ext, "xm") == 0) {
local->data = dumb_load_xm(file);
} else {
PERROR("Libdumb Source: No suitable module decoder found.");
goto error_0;
}
if(!local->data) {
PERROR("Libdumb Source: Error while loading module file!");
goto error_0;
}
local->renderer = duh_start_sigrenderer(local->data, 0, channels, 0);
local->vlen = duh_get_length(local->data);
local->vpos = 0;
local->sig_samples = NULL;
local->sig_samples_size = 0;
// Set resampler here
dumb_it_set_resampling_quality(duh_get_it_sigrenderer(local->renderer), resampler);
// Audio information
source_set_frequency(src, freq);
source_set_bytes(src, 2);
source_set_channels(src, channels);
source_set_resampler(src, resampler);
// Set callbacks
source_set_userdata(src, local);
source_set_update_cb(src, dumb_source_update);
source_set_close_cb(src, dumb_source_close);
// Some debug info
DEBUG("Libdumb Source: Loaded file '%s' succesfully.", file);
// All done
return 0;
error_0:
free(local);
return 1;
}
/* ModMusic::getDuration
* Returns the duration of the currently loaded mod
*******************************************************************/
sf::Time ModMusic::getDuration() const
{
return sf::seconds(static_cast<float>(duh_get_length(dumb_module) / 65536));
}
void* Init(const char* strFile, unsigned int filecache, int* channels,
int* samplerate, int* bitspersample, int64_t* totaltime,
int* bitrate, AEDataFormat* format, const AEChannel** channelinfo)
{
void* file = XBMC->OpenFile(strFile,0);
if (!file)
return NULL;
dumbfile_mem_status memdata;
memdata.size = XBMC->GetFileLength(file);
memdata.ptr = new uint8_t[memdata.size];
XBMC->ReadFile(file, const_cast<uint8_t*>(memdata.ptr), memdata.size);
XBMC->CloseFile(file);
DUMBFILE* f = dumbfile_open_ex(&memdata, &mem_dfs);
if (!f)
return NULL;
DumbContext* result = new DumbContext;
if (memdata.size >= 4 &&
memdata.ptr[0] == 'I' && memdata.ptr[1] == 'M' &&
memdata.ptr[2] == 'P' && memdata.ptr[3] == 'M')
{
result->module = dumb_read_it(f);
}
else if (memdata.size >= 17 &&
memcmp(memdata.ptr, "Extended Module: ", 17) == 0)
{
result->module = dumb_read_xm(f);
}
else if (memdata.size >= 0x30 &&
memdata.ptr[0x2C] == 'S' && memdata.ptr[0x2D] == 'C' &&
memdata.ptr[0x2E] == 'R' && memdata.ptr[0x2F] == 'M')
{
result->module = dumb_read_s3m(f);
}
else
{
dumbfile_close(f);
delete result;
return NULL;
}
dumbfile_close(f);
result->sr = duh_start_sigrenderer(result->module, 0, 2, 0);
if (!result->sr)
{
delete result;
return NULL;
}
*channels = 2;
*samplerate = 48000;
*bitspersample = 16;
*totaltime = duh_get_length(result->module)/65536*1000;
*format = AE_FMT_S16NE;
static enum AEChannel map[3] = { AE_CH_FL, AE_CH_FR , AE_CH_NULL};
*channelinfo = map;
*bitrate = duh_sigrenderer_get_n_channels(result->sr);
return result;
}
bool MODDecoder::Open(CFErrorRef *error)
{
if(IsOpen()) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioDecoder.MOD");
LOG4CXX_WARN(logger, "Open() called on an AudioDecoder that is already open");
return true;
}
// Ensure the input source is open
if(!mInputSource->IsOpen() && !mInputSource->Open(error))
return false;
dfs.open = NULL;
dfs.skip = skip_callback;
dfs.getc = getc_callback;
dfs.getnc = getnc_callback;
dfs.close = close_callback;
df = dumbfile_open_ex(this, &dfs);
if(NULL == df) {
return false;
}
CFStringRef fileSystemPath = CFURLCopyFileSystemPath(GetURL(), kCFURLPOSIXPathStyle);
CFStringRef extension = NULL;
CFRange range;
if(CFStringFindWithOptionsAndLocale(fileSystemPath, CFSTR("."), CFRangeMake(0, CFStringGetLength(fileSystemPath)), kCFCompareBackwards, CFLocaleGetSystem(), &range)) {
extension = CFStringCreateWithSubstring(kCFAllocatorDefault, fileSystemPath, CFRangeMake(range.location + 1, CFStringGetLength(fileSystemPath) - range.location - 1));
}
CFRelease(fileSystemPath), fileSystemPath = NULL;
if(NULL == extension) {
return false;
}
// Attempt to create the appropriate decoder based on the file's extension
if(kCFCompareEqualTo == CFStringCompare(extension, CFSTR("it"), kCFCompareCaseInsensitive))
duh = dumb_read_it(df);
else if(kCFCompareEqualTo == CFStringCompare(extension, CFSTR("xm"), kCFCompareCaseInsensitive))
duh = dumb_read_xm(df);
else if(kCFCompareEqualTo == CFStringCompare(extension, CFSTR("s3m"), kCFCompareCaseInsensitive))
duh = dumb_read_s3m(df);
else if(kCFCompareEqualTo == CFStringCompare(extension, CFSTR("mod"), kCFCompareCaseInsensitive))
duh = dumb_read_mod(df);
CFRelease(extension), extension = NULL;
if(NULL == duh) {
if(error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mInputSource->GetURL());
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MOD file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not a MOD file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioDecoderErrorDomain,
AudioDecoderInputOutputError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
if(df)
dumbfile_close(df), df = NULL;
return false;
}
mTotalFrames = duh_get_length(duh);
dsr = duh_start_sigrenderer(duh, 0, 2, 0);
if(NULL == dsr) {
if(error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mInputSource->GetURL());
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MOD file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not a MOD file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioDecoderErrorDomain,
AudioDecoderInputOutputError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
if(df)
dumbfile_close(df), df = NULL;
if(duh)
unload_duh(duh), duh = NULL;
return false;
}
// Generate interleaved 2 channel 44.1 16-bit output
mFormat.mFormatID = kAudioFormatLinearPCM;
mFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
mFormat.mSampleRate = DUMB_SAMPLE_RATE;
mFormat.mChannelsPerFrame = DUMB_CHANNELS;
mFormat.mBitsPerChannel = DUMB_BIT_DEPTH;
mFormat.mBytesPerPacket = (mFormat.mBitsPerChannel / 8) * mFormat.mChannelsPerFrame;
mFormat.mFramesPerPacket = 1;
mFormat.mBytesPerFrame = mFormat.mBytesPerPacket * mFormat.mFramesPerPacket;
mFormat.mReserved = 0;
// Set up the source format
mSourceFormat.mFormatID = 'MOD ';
mSourceFormat.mSampleRate = DUMB_SAMPLE_RATE;
mSourceFormat.mChannelsPerFrame = DUMB_CHANNELS;
// Setup the channel layout
mChannelLayout = CreateChannelLayoutWithTag(kAudioChannelLayoutTag_Stereo);
mIsOpen = true;
return true;
}
int main(int argc, char *argv[]) {
int retcode = 1;
int nerrors = 0;
streamer_t streamer;
memset(&streamer, 0, sizeof(streamer_t));
// Signal handlers
signal(SIGINT, sig_fn);
signal(SIGTERM, sig_fn);
// Initialize SDL2
if (SDL_Init(SDL_INIT_AUDIO) != 0) {
fprintf(stderr, "%s\n", SDL_GetError());
return 1;
}
// Defaults
streamer.freq = 44100;
streamer.n_channels = 2;
streamer.bits = 16;
streamer.volume = 1.0f;
streamer.quality = DUMB_RQ_CUBIC;
// commandline argument parser options
struct arg_lit *arg_help =
arg_lit0("h", "help", "print this help and exits");
struct arg_dbl *arg_volume =
arg_dbl0("v", "volume", "<volume",
"sets the output volume (-8.0 to +8.0, default 1.0)");
struct arg_int *arg_samplerate = arg_int0(
"s", "samplerate", "<freq>", "sets the sampling rate (default 44100)");
struct arg_int *arg_quality = arg_int0(
"r", "quality", "<quality>", "specify the resampling quality to use");
struct arg_lit *arg_mono =
arg_lit0("m", "mono", "generate mono output instead of stereo");
struct arg_lit *arg_eight =
arg_lit0("8", "eight", "generate 8-bit instead of 16-bit");
struct arg_lit *arg_noprogress =
arg_lit0("n", "noprogress", "hide progress bar");
struct arg_file *arg_output =
arg_file0("o", "output", "<file>", "output file");
struct arg_file *arg_input =
arg_file1(NULL, NULL, "<file>", "input module file");
struct arg_end *arg_fend = arg_end(20);
void *argtable[] = {arg_help, arg_input, arg_volume,
arg_samplerate, arg_quality, arg_mono,
arg_eight, arg_noprogress, arg_fend};
const char *progname = "dumbplay";
// Make sure everything got allocated
if (arg_nullcheck(argtable) != 0) {
fprintf(stderr, "%s: insufficient memory\n", progname);
goto exit_0;
}
// Parse inputs
nerrors = arg_parse(argc, argv, argtable);
// Handle help
if (arg_help->count > 0) {
fprintf(stderr, "Usage: %s", progname);
arg_print_syntax(stderr, argtable, "\n");
fprintf(stderr, "\nArguments:\n");
arg_print_glossary(stderr, argtable, "%-25s %s\n");
goto exit_0;
}
// Handle libargtable errors
if (nerrors > 0) {
arg_print_errors(stderr, arg_fend, progname);
fprintf(stderr, "Try '%s --help' for more information.\n", progname);
goto exit_0;
}
// Handle the switch options
streamer.input = arg_input->filename[0];
if (arg_eight->count > 0) {
streamer.bits = 8;
}
if (arg_mono->count > 0) {
streamer.n_channels = 1;
}
if (arg_noprogress->count > 0) {
streamer.no_progress = true;
}
if (arg_volume->count > 0) {
streamer.volume = arg_volume->dval[0];
if (streamer.volume < -8.0f || streamer.volume > 8.0f) {
fprintf(stderr, "Volume must be between -8.0f and 8.0f.\n");
goto exit_0;
}
}
if (arg_samplerate->count > 0) {
streamer.freq = arg_samplerate->ival[0];
if (streamer.freq < 1 || streamer.freq > 96000) {
fprintf(stderr, "Sampling rate must be between 1 and 96000.\n");
goto exit_0;
}
}
if (arg_quality->count > 0) {
streamer.quality = arg_quality->ival[0];
if (streamer.quality < 0 || streamer.quality >= DUMB_RQ_N_LEVELS) {
fprintf(stderr, "Quality must be between %d and %d.\n", 0,
DUMB_RQ_N_LEVELS - 1);
goto exit_0;
}
}
// Load source file.
dumb_register_stdfiles();
streamer.src = dumb_load_any(streamer.input, 0, 0);
if (!streamer.src) {
fprintf(stderr, "Unable to load file %s for playback!\n",
streamer.input);
goto exit_0;
}
// Set up playback
streamer.renderer =
duh_start_sigrenderer(streamer.src, 0, streamer.n_channels, 0);
streamer.delta = 65536.0f / streamer.freq;
streamer.sbytes = (streamer.bits / 8) * streamer.n_channels;
streamer.ssize = duh_get_length(streamer.src);
// Stop producing samples on module end
DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer(streamer.renderer);
dumb_it_set_loop_callback(itsr, &dumb_it_callback_terminate, NULL);
dumb_it_set_xm_speed_zero_callback(itsr, &dumb_it_callback_terminate, NULL);
dumb_it_set_resampling_quality(itsr, streamer.quality);
// Set up the SDL2 format we want for playback.
SDL_AudioSpec want;
SDL_zero(want);
want.freq = streamer.freq;
want.format = (streamer.bits == 16) ? AUDIO_S16 : AUDIO_S8;
want.channels = streamer.n_channels;
want.samples = SAMPLES;
want.callback = stream_audio;
want.userdata = &streamer;
// Find SDL2 audio device, and request the format we just set up.
// SDL2 will tell us what we got in the "have" struct.
SDL_AudioSpec have;
streamer.dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0);
if (streamer.dev == 0) {
fprintf(stderr, "%s\n", SDL_GetError());
goto exit_1;
}
// Make sure we got the format we wanted. If not, stop here.
if (have.format != want.format) {
fprintf(stderr, "Could not get correct playback format.\n");
goto exit_2;
}
// Play file
SDL_PauseAudioDevice(streamer.dev, 0);
// Show initial state of the progress bar (if it is enabled)
int time_start = SDL_GetTicks();
float seek = 0.0f;
int ms_played = 0;
if (!streamer.no_progress) {
show_progress(PROGRESSBAR_LENGTH, seek, ms_played);
}
// Loop while dumb is still giving data. Update progressbar if enabled.
while (!stop_signal && !streamer.ended) {
if (!streamer.no_progress) {
seek = ((float)streamer.spos) / ((float)streamer.ssize);
ms_played = SDL_GetTicks() - time_start;
show_progress(PROGRESSBAR_LENGTH, seek, ms_played);
}
SDL_Delay(100);
}
// We made it this far without crashing, so let's just exit with no error :)
retcode = 0;
// Free up resources and exit.
if (streamer.sig_samples) {
destroy_sample_buffer(streamer.sig_samples);
}
exit_2:
SDL_CloseAudioDevice(streamer.dev);
exit_1:
if (streamer.renderer) {
duh_end_sigrenderer(streamer.renderer);
}
if (streamer.src) {
unload_duh(streamer.src);
}
exit_0:
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
SDL_Quit();
return retcode;
}
bool SFB::Audio::MODDecoder::_Open(CFErrorRef *error)
{
dfs.open = nullptr;
dfs.skip = skip_callback;
dfs.getc = getc_callback;
dfs.getnc = getnc_callback;
dfs.close = close_callback;
df = unique_DUMBFILE_ptr(dumbfile_open_ex(this, &dfs), dumbfile_close);
if(!df) {
return false;
}
SFB::CFString pathExtension = CFURLCopyPathExtension(GetURL());
if(nullptr == pathExtension)
return false;
// Attempt to create the appropriate decoder based on the file's extension
if(kCFCompareEqualTo == CFStringCompare(pathExtension, CFSTR("it"), kCFCompareCaseInsensitive))
duh = unique_DUH_ptr(dumb_read_it(df.get()), unload_duh);
else if(kCFCompareEqualTo == CFStringCompare(pathExtension, CFSTR("xm"), kCFCompareCaseInsensitive))
duh = unique_DUH_ptr(dumb_read_xm(df.get()), unload_duh);
else if(kCFCompareEqualTo == CFStringCompare(pathExtension, CFSTR("s3m"), kCFCompareCaseInsensitive))
duh = unique_DUH_ptr(dumb_read_s3m(df.get()), unload_duh);
else if(kCFCompareEqualTo == CFStringCompare(pathExtension, CFSTR("mod"), kCFCompareCaseInsensitive))
duh = unique_DUH_ptr(dumb_read_mod(df.get()), unload_duh);
if(!duh) {
if(error) {
SFB::CFString description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MOD file."), "");
SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("Not a MOD file"), "");
SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
return false;
}
// NB: This must change if the sample rate changes because it is based on 65536 Hz
mTotalFrames = duh_get_length(duh.get());
dsr = unique_DUH_SIGRENDERER_ptr(duh_start_sigrenderer(duh.get(), 0, 2, 0), duh_end_sigrenderer);
if(!dsr) {
if(error) {
SFB::CFString description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MOD file."), "");
SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("Not a MOD file"), "");
SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
return false;
}
// Generate interleaved 2 channel 44.1 16-bit output
mFormat.mFormatID = kAudioFormatLinearPCM;
mFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
mFormat.mSampleRate = DUMB_SAMPLE_RATE;
mFormat.mChannelsPerFrame = DUMB_CHANNELS;
mFormat.mBitsPerChannel = DUMB_BIT_DEPTH;
mFormat.mBytesPerPacket = (mFormat.mBitsPerChannel / 8) * mFormat.mChannelsPerFrame;
mFormat.mFramesPerPacket = 1;
mFormat.mBytesPerFrame = mFormat.mBytesPerPacket * mFormat.mFramesPerPacket;
mFormat.mReserved = 0;
// Set up the source format
mSourceFormat.mFormatID = 'MOD ';
mSourceFormat.mSampleRate = DUMB_SAMPLE_RATE;
mSourceFormat.mChannelsPerFrame = DUMB_CHANNELS;
// Setup the channel layout
mChannelLayout = ChannelLayout::ChannelLayoutWithTag(kAudioChannelLayoutTag_Stereo);
return true;
}
