virtual alure::SharedPtr<alure::Decoder> createDecoder(alure::UniquePtr<std::istream> &file) { static const std::array<DUH*(*)(DUMBFILE*),3> init_funcs{{ dumb_read_it, dumb_read_xm, dumb_read_s3m }}; auto dfs = alure::MakeUnique<DUMBFILE_SYSTEM>(); dfs->open = nullptr; dfs->skip = cb_skip; dfs->getc = cb_read_char; dfs->getnc = cb_read; dfs->close = nullptr; dfs->seek = cb_seek; dfs->get_size = cb_get_size; DUMBFILE *dfile = dumbfile_open_ex(file.get(), dfs.get()); if(!dfile) return nullptr; ALuint freq = alure::Context::GetCurrent()->getDevice()->getFrequency(); DUH_SIGRENDERER *renderer; DUH *duh; for(auto init : init_funcs) { if((duh=init(dfile)) != nullptr) { if((renderer=duh_start_sigrenderer(duh, 0, 2, 0)) != nullptr) return alure::MakeShared<DumbDecoder>( std::move(file), std::move(dfs), dfile, duh, renderer, freq ); unload_duh(duh); duh = nullptr; } dumbfile_seek(dfile, 0, SEEK_SET); } if((duh=dumb_read_mod(dfile, 1)) != nullptr) { if((renderer=duh_start_sigrenderer(duh, 0, 2, 0)) != nullptr) return alure::MakeShared<DumbDecoder>( std::move(file), std::move(dfs), dfile, duh, renderer, freq ); unload_duh(duh); duh = nullptr; } dumbfile_close(dfile); return nullptr; }
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; }
// play a module using portaudio. void play(DUH *duh) { // init portaudio, redirecting stderr output temporarily; a lot of junk // gets printed otherwise. this won't work on windows, but who cares? int old_stderr = dup(2); int new_stderr = open("/dev/null", O_WRONLY); dup2(new_stderr, 2); PaError err = Pa_Initialize(); close(new_stderr); dup2(old_stderr, 2); close(old_stderr); if (err != paNoError) die("could not init PortAudio: %s\n", Pa_GetErrorText(err)); atexit(&pa_terminate); // get default device info PaDeviceIndex index = Pa_GetDefaultOutputDevice(); if (index == paNoDevice) die("could not get default output device\n"); callback_data cd; const PaDeviceInfo *dev = Pa_GetDeviceInfo(index); cd.sample_rate = dev->defaultSampleRate; cd.delta = 65536.0f / cd.sample_rate; // open and start output stream PaStream *stream; cd.sr = duh_start_sigrenderer(duh, 0, channels, 0); err = Pa_OpenDefaultStream(&stream, 0, channels, paInt16, dev->defaultSampleRate, paFramesPerBufferUnspecified, callback, &cd); if (err != paNoError) { duh_end_sigrenderer(cd.sr); unload_duh(duh); die("could not open default stream: %s\n", Pa_GetErrorText(err)); } if ((err = Pa_StartStream(stream)) != paNoError) { duh_end_sigrenderer(cd.sr); unload_duh(duh); die("could not start stream: %s\n", Pa_GetErrorText(err)); } init_sigrenderer(cd.sr); // play while (Pa_IsStreamActive(stream) == 1) Pa_Sleep(100); // clean up Pa_CloseStream(stream); duh_end_sigrenderer(cd.sr); }
void Tracker_Play(byte track, qboolean looping) { if(bTracker_Initialized == false) return; alGenSources((ALuint)1, &oss_source); alSourcef(oss_source, AL_PITCH, 1); alSourcef(oss_source, AL_GAIN, 1); alSource3f(oss_source, AL_POSITION, 0, 0, 0); alSource3f(oss_source, AL_VELOCITY, 0, 0, 0); alSourcei(oss_source, AL_LOOPING, AL_FALSE); alGenBuffers((ALuint)1, &oss_buffer); dumb_register_stdfiles(); // Initialize loading files // Attempt to load every format imaginable, TODO: better method? sprintf (name, "%s/music/track%d.it", com_gamedir, track); trackmod = dumb_load_it(name); if (!trackmod) { sprintf (name, "%s/music/track%d.xm", com_gamedir, track); trackmod = dumb_load_xm(name); if (!trackmod) { sprintf (name, "%s/music/track%d.s3m", com_gamedir, track); trackmod = dumb_load_s3m(name); if (!trackmod) { sprintf (name, "%s/music/track%d.mod", com_gamedir, track); trackmod = dumb_load_mod(name); if (!trackmod) { fprintf(stderr, "Unable to open %s!\n", name); return; } } } } // Let us know which track you are playing Con_Printf("Playing %s\n", name); sr = duh_start_sigrenderer(trackmod, 0, n_channels, 0); // start rendering, action happens in Tracker_Update if (!sr) { // If it doesn't want to render, stop it before it's too late unload_duh(trackmod); // Unload the track safely fprintf(stderr, "Unable to play file!\n"); return; } delta = 61536.0f / freq; // This affects the speed bufsize = depth == 16 ? 2048 : 4096; // Buffer size, small buffer = laggy music; big buff = laggy game bufsize /= n_channels; // Tell him we are hopefully stereo playing = true; // Announce that we have a track playing }
AL_DUH_PLAYER *al_start_duh(DUH *duh, int n_channels, long pos, float volume, long bufsize, int freq) { AL_DUH_PLAYER *dp; /* This restriction is imposed by Allegro. */ ASSERT(n_channels > 0); ASSERT(n_channels <= 2); if (!duh) return NULL; dp = malloc(sizeof(*dp)); if (!dp) return NULL; dp->flags = ADP_PLAYING; dp->bufsize = bufsize; dp->freq = freq; dp->stream = play_audio_stream(bufsize, 16, n_channels - 1, freq, 255, 128); if (!dp->stream) { free(dp); return NULL; } voice_set_priority(dp->stream->voice, 255); dp->sigrenderer = duh_start_sigrenderer(duh, 0, n_channels, pos); if (!dp->sigrenderer) { stop_audio_stream(dp->stream); free(dp); return NULL; } dp->volume = volume; dp->silentcount = 0; return dp; }
static int cdumb_startrenderer (DB_fileinfo_t *_info) { dumb_info_t *info = (dumb_info_t *)_info; // reopen if (info->renderer) { duh_end_sigrenderer (info->renderer); info->renderer = NULL; } info->renderer = duh_start_sigrenderer (info->duh, 0, 2, 0); if (!info->renderer) { return -1; } DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer (info->renderer); dumb_it_set_loop_callback (itsr, &dumb_it_callback_terminate, NULL); int q = conf_resampling_quality; if (q < 0) { q = 0; } else if (q >= DUMB_RQ_N_LEVELS) { q = DUMB_RQ_N_LEVELS - 1; } dumb_it_set_resampling_quality (itsr, q); dumb_it_set_xm_speed_zero_callback (itsr, &dumb_it_callback_terminate, NULL); dumb_it_set_global_volume_zero_callback (itsr, &dumb_it_callback_terminate, NULL); int rq = conf_ramping_style; if (rq < 0) { rq = 0; } else if (rq > 2) { rq = 2; } dumb_it_set_ramp_style(itsr, rq); dumb_it_sr_set_global_volume (itsr, conf_global_volume); return 0; }
// ----------------------------------------------------------------------------- // Loads mod data for playback // ----------------------------------------------------------------------------- bool ModMusic::loadFromMemory(const uint8_t* data, const uint32_t size) { // Init DUMB if needed if (!init_done_) initDumb(); // Close current module if any close(); // Load module file dumb_module_ = dumb_read_any(dumbfile_open_memory((const char*)data, size), 0, 0); if (dumb_module_ != nullptr) { initialize(2, 44100); dumb_player_ = duh_start_sigrenderer(dumb_module_, 0, 2, 0); return true; } else { Log::error("Failed to load module music data"); return false; } }
/* ModMusic::onSeek * Called when seeking is requested on the sound stream *******************************************************************/ void ModMusic::onSeek(sf::Time timeOffset) { long pos = static_cast<long>(timeOffset.asSeconds() * 65536); dumb_player = duh_start_sigrenderer(dumb_module, 0, 2, pos); //dumb_it_set_loop_callback(duh_get_it_sigrenderer(dumb_player), dumb_it_callback_terminate, NULL); }
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; }
/* DEPRECATED */ DUH_SIGRENDERER *duh_start_renderer(DUH *duh, int n_channels, long pos) { return duh_start_sigrenderer(duh, 0, n_channels, pos); }
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; }