static void prepare_for_open(service_ptr_t<input_entry> & p_service,service_ptr_t<file> & p_file,const char * p_path,filesystem::t_open_mode p_open_mode,abort_callback & p_abort,bool p_from_redirect) { if (p_file.is_empty()) { service_ptr_t<filesystem> fs; if (filesystem::g_get_interface(fs,p_path)) { if (fs->supports_content_types()) { fs->open(p_file,p_path,p_open_mode,p_abort); } } } if (p_file.is_valid()) { pfc::string8 content_type; if (p_file->get_content_type(content_type)) { if (input_entry::g_find_service_by_content_type(p_service,content_type)) return; } } if (input_entry::g_find_service_by_path(p_service,p_path)) { if (p_from_redirect && p_service->is_redirect()) throw exception_io_unsupported_format(); return; } throw exception_io_unsupported_format(); }
service_ptr input_entry::g_open_from_list(input_entry_list_t const & p_list, const GUID & whatFor, service_ptr_t<file> p_filehint, const char * p_path, abort_callback & p_abort, GUID * outGUID) { const t_size count = p_list.get_count(); if ( count == 0 ) { // sanity throw exception_io_unsupported_format(); } else if (count == 1) { auto ret = p_list[0]->open(whatFor, p_filehint, p_path, p_abort); if ( outGUID != nullptr ) * outGUID = input_get_guid( p_list[0] ); return ret; } else { unsigned bad_data_count = 0; pfc::string8 bad_data_message; for (t_size n = 0; n < count; n++) { try { auto ret = p_list[n]->open(whatFor, p_filehint, p_path, p_abort); if (outGUID != nullptr) * outGUID = input_get_guid(p_list[n]); return ret; } catch (exception_io_no_handler_for_path) { //do nothing, skip over } catch (exception_io_unsupported_format) { //do nothing, skip over } catch (exception_io_data const & e) { if (bad_data_count++ == 0) bad_data_message = e.what(); } } if (bad_data_count > 1) throw exception_io_data(); else if (bad_data_count == 0) pfc::throw_exception_with_message<exception_io_data>(bad_data_message); else throw exception_io_unsupported_format(); } }
void open(service_ptr_t<file> p_filehint,const char * p_path,t_input_open_reason p_reason,abort_callback & p_abort) { if ( p_reason == input_open_info_write ) { throw exception_io_unsupported_format(); // our input does not support retagging. } m_file = p_filehint; // p_filehint may be null, hence next line input_open_file_helper(m_file,p_path,p_reason,p_abort); // if m_file is null, opens file with appropriate privileges for our operation (read/write for writing tags, read-only otherwise). if ( m_file->get_size( p_abort ) >= (std::numeric_limits<std::size_t>::max)() ) { throw exception_io_unsupported_format(); } std::vector<char> data( static_cast<std::size_t>( m_file->get_size( p_abort ) ) ); m_file->read( data.data(), data.size(), p_abort ); try { std::map< std::string, std::string > ctls; ctls["seek.sync_samples"] = "1"; mod = new openmpt::module( data, std::clog, ctls ); } catch ( std::exception & /*e*/ ) { throw exception_io_data(); } settings = foo_openmpt_settings(); mod->set_repeat_count( settings.repeatcount ); mod->set_render_param( openmpt::module::RENDER_MASTERGAIN_MILLIBEL, settings.mastergain_millibel ); mod->set_render_param( openmpt::module::RENDER_STEREOSEPARATION_PERCENT, settings.stereoseparation ); mod->set_render_param( openmpt::module::RENDER_INTERPOLATIONFILTER_LENGTH, settings.interpolationfilterlength ); mod->set_render_param( openmpt::module::RENDER_VOLUMERAMPING_STRENGTH, settings.ramping ); mod->ctl_set( "render.resampler.emulate_amiga", settings.use_amiga_resampler ? "1" : "0" ); }
void open(service_ptr_t<file> p_filehint, const char *p_path, t_input_open_reason p_reason, abort_callback &p_abort) { if (p_reason == input_open_info_write) { int len = strlen(p_path); if (len < 4 || _stricmp(p_path + len - 4, ".sap") != 0) throw exception_io_unsupported_format(); filename = strdup(p_path); } if (p_filehint.is_empty()) filesystem::g_open(p_filehint, p_path, filesystem::open_mode_read, p_abort); m_file = p_filehint; module_len = m_file->read(module, sizeof(module), p_abort); if (!ASAP_Load(asap, p_path, module, module_len)) throw exception_io_unsupported_format(); }
void decode_initialize(t_uint32 p_subsong, unsigned p_flags, abort_callback &p_abort) { int duration = get_song_duration(p_subsong, true); if (!ASAP_PlaySong(asap, p_subsong, duration)) throw exception_io_unsupported_format(); ASAP_MutePokeyChannels(asap, mute_mask); }
virtual bool open_path_internal(file::ptr p_filehint,const char * path,t_input_open_reason p_reason,abort_callback & p_abort,bool p_from_redirect,bool p_skip_hints) { if (p_reason == input_open_info_write) throw exception_io_unsupported_format();//our input does not support retagging. try { open_path_helper(m_input, p_filehint, path, p_abort, p_from_redirect,p_skip_hints); } catch (exception_io_not_found) { return false; } switch_input(m_input, path); file_info_impl p_info; get_input()->get_info(0, p_info, p_abort); m_points.remove_all(); if (m_by_meta) { if (p_info.meta_get_count_by_name("LOOPSTART") != 1 || p_info.meta_get_count_by_name("LOOPLENGTH") != 1) return false; } loop_event_point_simple * point = new service_impl_t<loop_event_point_simple>(); if (m_by_meta) { m_loopstart = pfc::atoui64_ex(p_info.meta_get("LOOPSTART", 0), ~0); m_looplength = pfc::atoui64_ex(p_info.meta_get("LOOPLENGTH", 0), ~0); } point->from = m_loopstart + m_looplength; point->to = m_loopstart; m_points.add_item(point); switch_points(m_points); return true; }
service_ptr input_entry::open(const GUID & whatFor, file::ptr hint, const char * path, abort_callback & aborter) { if (whatFor == input_decoder::class_guid) { input_decoder::ptr obj; open(obj, hint, path, aborter); return obj; } if (whatFor == input_info_reader::class_guid) { input_info_reader::ptr obj; open(obj, hint, path, aborter); return obj; } if (whatFor == input_info_writer::class_guid) { input_info_writer::ptr obj; open(obj, hint, path, aborter); return obj; } #ifdef FOOBAR2000_DESKTOP if ( whatFor == input_stream_info_reader::class_guid ) { input_entry_v2::ptr v2; if ( v2 &= this ) { GUID g = v2->get_guid(); service_enum_t<input_stream_info_reader_entry> e; service_ptr_t<input_stream_info_reader_entry> p; while (e.next(p)) { if (p->get_guid() == g) { return p->open( path, hint, aborter ); } } } throw exception_io_unsupported_format(); } #endif uBugCheck(); }
service_ptr input_entry::g_open(const GUID & whatFor, file::ptr p_filehint, const char * p_path, abort_callback & p_abort, bool p_from_redirect) { #ifdef FOOBAR2000_DESKTOP #if FOOBAR2000_TARGET_VERSION >= 79 return input_manager::get()->open(whatFor, p_filehint, p_path, p_from_redirect, p_abort); #endif { input_manager::ptr m; service_enum_t<input_manager> e; if (e.next(m)) { return m->open(whatFor, p_filehint, p_path, p_from_redirect, p_abort); } } #endif const bool needWriteAcecss = !!(whatFor == input_info_writer::class_guid); service_ptr_t<file> l_file = p_filehint; if (l_file.is_empty()) { service_ptr_t<filesystem> fs; if (filesystem::g_get_interface(fs, p_path)) { if (fs->supports_content_types()) { fs->open(l_file, p_path, needWriteAcecss ? filesystem::open_mode_write_existing : filesystem::open_mode_read, p_abort); } } } if (l_file.is_valid()) { pfc::string8 content_type; if (l_file->get_content_type(content_type)) { pfc::list_t< input_entry::ptr > list; #if PFC_DEBUG FB2K_DebugLog() << "attempting input open by content type: " << content_type; #endif if (g_find_inputs_by_content_type(list, content_type, p_from_redirect)) { try { return g_open_from_list(list, whatFor, l_file, p_path, p_abort); } catch (exception_io_unsupported_format) { #if PFC_DEBUG FB2K_DebugLog() << "Failed to open by content type, using fallback"; #endif } } } } #if PFC_DEBUG FB2K_DebugLog() << "attempting input open by path: " << p_path; #endif { pfc::list_t< input_entry::ptr > list; if (g_find_inputs_by_path(list, p_path, p_from_redirect)) { return g_open_from_list(list, whatFor, l_file, p_path, p_abort); } } throw exception_io_unsupported_format(); }
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(); }
void playlist_loader::g_load_playlist_filehint(file::ptr fileHint,const char * p_path,playlist_loader_callback & p_callback) { TRACK_CALL_TEXT("playlist_loader::g_load_playlist_filehint"); pfc::string8 filepath; filesystem::g_get_canonical_path(p_path,filepath); pfc::string_extension extension(filepath); service_ptr_t<file> l_file = fileHint; if (l_file.is_empty()) { filesystem::ptr fs; if (filesystem::g_get_interface(fs,filepath)) { if (fs->supports_content_types()) { fs->open(l_file,filepath,filesystem::open_mode_read,p_callback); } } } { service_enum_t<playlist_loader> e; if (l_file.is_valid()) { pfc::string8 content_type; if (l_file->get_content_type(content_type)) { service_ptr_t<playlist_loader> l; e.reset(); while(e.next(l)) { if (l->is_our_content_type(content_type)) { try { TRACK_CODE("playlist_loader::open",l->open(filepath,l_file,p_callback)); return; } catch(exception_io_unsupported_format) { l_file->reopen(p_callback); } } } } } if (extension.length()>0) { service_ptr_t<playlist_loader> l; e.reset(); while(e.next(l)) { if (stricmp_utf8(l->get_extension(),extension) == 0) { if (l_file.is_empty()) filesystem::g_open_read(l_file,filepath,p_callback); try { TRACK_CODE("playlist_loader::open",l->open(filepath,l_file,p_callback)); return; } catch(exception_io_unsupported_format) { l_file->reopen(p_callback); } } } } } throw exception_io_unsupported_format(); }
void open(service_ptr_t<file> p_filehint, const char *p_path, t_input_open_reason p_reason, abort_callback &p_abort) { if (p_reason == input_open_info_write) { int len = strlen(p_path); if (len >= MAX_PATH || !ASAP_CanSetModuleInfo(p_path)) throw exception_io_unsupported_format(); memcpy(filename, p_path, len + 1); } if (p_filehint.is_empty()) filesystem::g_open(p_filehint, p_path, filesystem::open_mode_read, p_abort); m_file = p_filehint; module_len = m_file->read(module, sizeof(module), p_abort); if (!ASAP_GetModuleInfo(&module_info, p_path, module, module_len)) throw exception_io_unsupported_format(); if (p_reason == input_open_decode) if (!ASAP_Load(&asap, p_path, module, module_len)) throw exception_io_unsupported_format(); }
void retag_commit(abort_callback &p_abort) { byte out_module[ASAP_MODULE_MAX]; int out_len = ASAP_SetModuleInfo(&module_info, module, module_len, out_module); if (out_len <= 0) throw exception_io_unsupported_format(); m_file.release(); filesystem::g_open(m_file, filename, filesystem::open_mode_write_new, p_abort); m_file->write(out_module, out_len, p_abort); }
void retag(const file_info & p_info,abort_callback & p_abort) {throw exception_io_unsupported_format();}
void open(service_ptr_t<file> p_filehint,const char * p_path,t_input_open_reason p_reason,abort_callback & p_abort) { if (p_reason == input_open_info_write) throw exception_io_unsupported_format();//our input does not support retagging. m_file = p_filehint;//p_filehint may be null, hence next line input_open_file_helper(m_file,p_path,p_reason,p_abort);//if m_file is null, opens file with appropriate privileges for our operation (read/write for writing tags, read-only otherwise). }
virtual bool open_path_internal(file::ptr p_filehint,const char * p_path,t_input_open_reason p_reason,abort_callback & p_abort,bool p_from_redirect,bool p_skip_hints) { if (p_reason == input_open_info_write) throw exception_io_unsupported_format();//our input does not support retagging. pfc::string8 base, ext; base = p_path; t_size extpos = base.find_last('.'); if (extpos >= base.scan_filename()) { // is ext ext.set_string(base + extpos); base.truncate(extpos); } else { ext = ""; } if (m_autoprobe) { // try some known suffixes bool found = false; unsigned n; pfc::string8 work(base); t_size baselen = base.get_length(); for(n=0;n<tabsize(g_known_suffix_table);n++) { const char *head_suffix = g_known_suffix_table[n].head_suffix; const char *body_suffix = g_known_suffix_table[n].body_suffix; work.truncate(baselen); work << head_suffix << ext; if (!filesystem::g_exists(work, p_abort)) continue; work.truncate(baselen); work << body_suffix << ext; if (!filesystem::g_exists(work, p_abort)) continue; m_head.suffix = head_suffix; m_body.suffix = body_suffix; found = true; break; } if (!found) return false; } m_head.path.reset(); m_head.path << base << m_head.suffix << ext; filesystem::g_get_canonical_path(m_head.path, m_head.path); try { open_path_helper(m_head.input, NULL, m_head.path, p_abort, p_from_redirect, p_skip_hints); } catch (exception_io_not_found) { return false; } m_body.path.reset(); m_body.path << base << m_body.suffix << ext; filesystem::g_get_canonical_path(m_body.path, m_body.path); try { open_path_helper(m_body.input, NULL, m_body.path, p_abort, p_from_redirect, p_skip_hints); } catch (exception_io_not_found) { console::formatter() << "loop twofiles: body file not found: \"" << file_path_display(m_body.path) << "\""; return false; } if (m_head.input.is_empty() || m_body.input.is_empty()) return false; m_points.remove_all(); loop_event_point_twofiles_eof * point = new service_impl_t<loop_event_point_twofiles_eof>(); m_points.add_item(point); switch_points(m_points); file_info_impl p_info; m_head.input->get_info(0, p_info, p_abort); m_head.samples = p_info.info_get_length_samples(); p_info.reset(); m_body.input->get_info(0, p_info, p_abort); m_body.samples = p_info.info_get_length_samples(); switch_to(m_head); return true; }
void playlist_loader::g_load_playlist_filehint(file::ptr fileHint,const char * p_path,playlist_loader_callback::ptr p_callback, abort_callback & p_abort) { if (!g_try_load_playlist(fileHint, p_path, p_callback, p_abort)) throw exception_io_unsupported_format(); }