1894 lines
56 KiB
C++
1894 lines
56 KiB
C++
/*
|
|
* xmp-openmpt.cpp
|
|
* ---------------
|
|
* Purpose: libopenmpt xmplay input plugin implementation
|
|
* Notes : (currently none)
|
|
* Authors: OpenMPT Devs
|
|
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
|
*/
|
|
|
|
#ifndef NO_XMPLAY
|
|
|
|
#ifndef _CRT_SECURE_NO_WARNINGS
|
|
#define _CRT_SECURE_NO_WARNINGS
|
|
#endif
|
|
#if !defined(WINVER) && !defined(_WIN32_WINDOWS)
|
|
#ifndef _WIN32_WINNT
|
|
#define _WIN32_WINNT 0x0501 // _WIN32_WINNT_WINXP
|
|
#endif
|
|
#endif
|
|
#if !defined(MPT_BUILD_RETRO)
|
|
#if defined(_MSC_VER)
|
|
#define MPT_WITH_MFC
|
|
#endif
|
|
#else
|
|
#if defined(_WIN32_WINNT)
|
|
#if (_WIN32_WINNT >= 0x0501)
|
|
#if defined(_MSC_VER)
|
|
#define MPT_WITH_MFC
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#if defined(MPT_WITH_MFC)
|
|
#define _AFX_NO_MFC_CONTROLS_IN_DIALOGS // Avoid binary bloat from linking unused MFC controls
|
|
#endif // MPT_WITH_MFC
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
#if defined(MPT_WITH_MFC)
|
|
#include <afxwin.h>
|
|
#include <afxcmn.h>
|
|
#endif // MPT_WITH_MFC
|
|
#include <windows.h>
|
|
#include <WindowsX.h>
|
|
|
|
#ifdef LIBOPENMPT_BUILD_DLL
|
|
#undef LIBOPENMPT_BUILD_DLL
|
|
#endif
|
|
|
|
#ifdef _MSC_VER
|
|
#ifndef _CRT_SECURE_NO_WARNINGS
|
|
#define _CRT_SECURE_NO_WARNINGS
|
|
#endif
|
|
#ifndef _SCL_SECURE_NO_WARNINGS
|
|
#define _SCL_SECURE_NO_WARNINGS
|
|
#endif
|
|
#endif // _MSC_VER
|
|
|
|
#include <cctype>
|
|
#include <cstring>
|
|
|
|
#include <tchar.h>
|
|
|
|
#include "libopenmpt.hpp"
|
|
#include "libopenmpt_ext.hpp"
|
|
|
|
#include "libopenmpt_plugin_settings.hpp"
|
|
|
|
#include "libopenmpt_plugin_gui.hpp"
|
|
|
|
#include "svn_version.h"
|
|
#if defined(OPENMPT_VERSION_REVISION)
|
|
static const char * xmp_openmpt_string = "OpenMPT (" OPENMPT_API_VERSION_STRING "." OPENMPT_API_VERSION_STRINGIZE(OPENMPT_VERSION_REVISION) ")";
|
|
#else
|
|
static const char * xmp_openmpt_string = "OpenMPT (" OPENMPT_API_VERSION_STRING ")";
|
|
#endif
|
|
|
|
#define USE_XMPLAY_FILE_IO
|
|
|
|
#define USE_XMPLAY_ISTREAM
|
|
|
|
#include "xmplay/xmpin.h"
|
|
|
|
// Shortcut block assigned to the OpenMPT plugin by un4seen.
|
|
enum {
|
|
openmpt_shortcut_first = 0x21000,
|
|
openmpt_shortcut_tempo_decrease = openmpt_shortcut_first,
|
|
openmpt_shortcut_tempo_increase,
|
|
openmpt_shortcut_pitch_decrease,
|
|
openmpt_shortcut_pitch_increase,
|
|
openmpt_shortcut_switch_interpolation,
|
|
openmpt_shortcut_last = 0x21fff,
|
|
|
|
openmpt_shortcut_ex = 0x80000000, // Use extended version of the shortcut callback
|
|
};
|
|
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <map>
|
|
#include <queue>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
#include <cmath>
|
|
|
|
#include <pugixml.hpp>
|
|
|
|
#define SHORT_TITLE "xmp-openmpt"
|
|
#define SHORTER_TITLE "openmpt"
|
|
|
|
static CRITICAL_SECTION xmpopenmpt_mutex;
|
|
class xmpopenmpt_lock {
|
|
public:
|
|
xmpopenmpt_lock() {
|
|
EnterCriticalSection( &xmpopenmpt_mutex );
|
|
}
|
|
~xmpopenmpt_lock() {
|
|
LeaveCriticalSection( &xmpopenmpt_mutex );
|
|
}
|
|
};
|
|
|
|
static XMPFUNC_IN * xmpfin = nullptr;
|
|
static XMPFUNC_MISC * xmpfmisc = nullptr;
|
|
static XMPFUNC_REGISTRY * xmpfregistry = nullptr;
|
|
static XMPFUNC_FILE * xmpffile = nullptr;
|
|
static XMPFUNC_TEXT * xmpftext = nullptr;
|
|
static XMPFUNC_STATUS * xmpfstatus = nullptr;
|
|
|
|
struct self_xmplay_t;
|
|
|
|
static self_xmplay_t * self = 0;
|
|
|
|
static void save_options();
|
|
|
|
static void apply_and_save_options();
|
|
|
|
|
|
static std::string convert_to_native( const std::string & str );
|
|
|
|
static std::string StringEncode( const std::wstring &src, UINT codepage );
|
|
|
|
static std::wstring StringDecode( const std::string & src, UINT codepage );
|
|
|
|
#if defined(UNICODE)
|
|
static std::wstring StringToWINAPI( const std::wstring & src );
|
|
#else
|
|
static std::string StringToWINAPI( const std::wstring & src );
|
|
#endif
|
|
|
|
class xmp_openmpt_settings
|
|
: public libopenmpt::plugin::settings
|
|
{
|
|
protected:
|
|
void read_setting( const std::string & key, const std::basic_string<TCHAR> & keyW, int & val ) override {
|
|
libopenmpt::plugin::settings::read_setting( key, keyW, val );
|
|
int storedVal = 0;
|
|
if ( xmpfregistry->GetInt( "OpenMPT", key.c_str(), &storedVal ) ) {
|
|
val = storedVal;
|
|
}
|
|
}
|
|
void write_setting( const std::string & key, const std::basic_string<TCHAR> & /* keyW */ , int val ) override {
|
|
if ( !xmpfregistry->SetInt( "OpenMPT", key.c_str(), &val ) ) {
|
|
// error
|
|
}
|
|
// ok
|
|
}
|
|
public:
|
|
xmp_openmpt_settings()
|
|
: libopenmpt::plugin::settings(TEXT(SHORT_TITLE), false)
|
|
{
|
|
return;
|
|
}
|
|
virtual ~xmp_openmpt_settings()
|
|
{
|
|
return;
|
|
}
|
|
};
|
|
|
|
struct self_xmplay_t {
|
|
std::vector<float> subsong_lengths;
|
|
std::vector<std::string> subsong_names;
|
|
std::size_t samplerate = 48000;
|
|
std::size_t num_channels = 2;
|
|
xmp_openmpt_settings settings;
|
|
openmpt::module_ext * mod = nullptr;
|
|
bool set_format_called = false;
|
|
openmpt::ext::pattern_vis * pattern_vis = nullptr;
|
|
std::int32_t tempo_factor = 0, pitch_factor = 0;
|
|
bool single_subsong_mode = false;
|
|
self_xmplay_t() {
|
|
settings.changed = apply_and_save_options;
|
|
}
|
|
void on_new_mod() {
|
|
set_format_called = false;
|
|
self->pattern_vis = static_cast<openmpt::ext::pattern_vis *>( self->mod->get_interface( openmpt::ext::pattern_vis_id ) );
|
|
}
|
|
void delete_mod() {
|
|
if ( mod ) {
|
|
pattern_vis = 0;
|
|
set_format_called = false;
|
|
delete mod;
|
|
mod = 0;
|
|
}
|
|
}
|
|
~self_xmplay_t() {
|
|
return;
|
|
}
|
|
};
|
|
|
|
static std::string convert_to_native( const std::string & str ) {
|
|
char * native_string = xmpftext->Utf8( str.c_str(), -1 );
|
|
std::string result = native_string ? native_string : "";
|
|
if ( native_string ) {
|
|
xmpfmisc->Free( native_string );
|
|
native_string = 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static std::string StringEncode( const std::wstring &src, UINT codepage )
|
|
{
|
|
int required_size = WideCharToMultiByte( codepage, 0, src.c_str(), -1, nullptr, 0, nullptr, nullptr);
|
|
if(required_size <= 0)
|
|
{
|
|
return std::string();
|
|
}
|
|
std::vector<CHAR> encoded_string( required_size );
|
|
WideCharToMultiByte( codepage, 0, src.c_str(), -1, &encoded_string[0], encoded_string.size(), nullptr, nullptr);
|
|
return &encoded_string[0];
|
|
}
|
|
|
|
static std::wstring StringDecode( const std::string & src, UINT codepage )
|
|
{
|
|
int required_size = MultiByteToWideChar( codepage, 0, src.c_str(), -1, nullptr, 0 );
|
|
if(required_size <= 0)
|
|
{
|
|
return std::wstring();
|
|
}
|
|
std::vector<WCHAR> decoded_string( required_size );
|
|
MultiByteToWideChar( codepage, 0, src.c_str(), -1, &decoded_string[0], decoded_string.size() );
|
|
return &decoded_string[0];
|
|
}
|
|
|
|
#if defined(UNICODE)
|
|
|
|
static std::wstring StringToWINAPI( const std::wstring & src )
|
|
{
|
|
return src;
|
|
}
|
|
|
|
#else
|
|
|
|
static std::string StringToWINAPI( const std::wstring & src )
|
|
{
|
|
return StringEncode( src, CP_ACP );
|
|
}
|
|
|
|
#endif
|
|
|
|
template <typename Tstring, typename Tstring2, typename Tstring3>
|
|
static inline Tstring StringReplace( Tstring str, const Tstring2 & oldStr_, const Tstring3 & newStr_ ) {
|
|
std::size_t pos = 0;
|
|
const Tstring oldStr = oldStr_;
|
|
const Tstring newStr = newStr_;
|
|
while ( ( pos = str.find( oldStr, pos ) ) != Tstring::npos ) {
|
|
str.replace( pos, oldStr.length(), newStr );
|
|
pos += newStr.length();
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static std::string StringUpperCase( std::string str ) {
|
|
std::transform( str.begin(), str.end(), str.begin(), []( char c ) { return static_cast<char>( std::toupper( c ) ); } );
|
|
return str;
|
|
}
|
|
|
|
static std::string seconds_to_string( float time ) {
|
|
std::int64_t time_ms = static_cast<std::int64_t>( time * 1000 );
|
|
std::int64_t seconds = ( time_ms / 1000 ) % 60;
|
|
std::int64_t minutes = ( time_ms / ( 1000 * 60 ) ) % 60;
|
|
std::int64_t hours = ( time_ms / ( 1000 * 60 * 60 ) );
|
|
std::ostringstream str;
|
|
if ( hours > 0 ) {
|
|
str << hours << ":";
|
|
}
|
|
str << std::setfill('0') << std::setw(2) << minutes;
|
|
str << ":";
|
|
str << std::setfill('0') << std::setw(2) << seconds;
|
|
return str.str();
|
|
}
|
|
|
|
static void save_settings_to_map( std::map<std::string,int> & result, const libopenmpt::plugin::settings & s ) {
|
|
result.clear();
|
|
result[ "Samplerate_Hz" ] = s.samplerate;
|
|
result[ "Channels" ] = s.channels;
|
|
result[ "MasterGain_milliBel" ] = s.mastergain_millibel;
|
|
result[ "StereoSeparation_Percent" ] = s.stereoseparation;
|
|
result[ "RepeatCount" ] = s.repeatcount;
|
|
result[ "InterpolationFilterLength" ] = s.interpolationfilterlength;
|
|
result[ "UseAmigaResampler" ] = s.use_amiga_resampler;
|
|
result[ "AmigaFilterType" ] = s.amiga_filter_type;
|
|
result[ "VolumeRampingStrength" ] = s.ramping;
|
|
}
|
|
|
|
static inline void load_map_setting( const std::map<std::string,int> & map, const std::string & key, int & val ) {
|
|
auto it = map.find( key );
|
|
if ( it != map.end() ) {
|
|
val = it->second;
|
|
}
|
|
}
|
|
|
|
static void load_settings_from_map( libopenmpt::plugin::settings & s, const std::map<std::string,int> & map ) {
|
|
load_map_setting( map, "Samplerate_Hz", s.samplerate );
|
|
load_map_setting( map, "Channels", s.channels );
|
|
load_map_setting( map, "MasterGain_milliBel", s.mastergain_millibel );
|
|
load_map_setting( map, "StereoSeparation_Percent", s.stereoseparation );
|
|
load_map_setting( map, "RepeatCount", s.repeatcount );
|
|
load_map_setting( map, "InterpolationFilterLength", s.interpolationfilterlength );
|
|
load_map_setting( map, "UseAmigaResampler", s.use_amiga_resampler );
|
|
load_map_setting( map, "AmigaFilterType", s.amiga_filter_type );
|
|
load_map_setting( map, "VolumeRampingStrength", s.ramping );
|
|
}
|
|
|
|
static void load_settings_from_xml( libopenmpt::plugin::settings & s, const std::string & xml ) {
|
|
pugi::xml_document doc;
|
|
doc.load_string( xml.c_str() );
|
|
pugi::xml_node settings_node = doc.child( "settings" );
|
|
std::map<std::string,int> map;
|
|
for ( const auto & attr : settings_node.attributes() ) {
|
|
map[ attr.name() ] = attr.as_int();
|
|
}
|
|
load_settings_from_map( s, map );
|
|
}
|
|
|
|
static void save_settings_to_xml( std::string & xml, const libopenmpt::plugin::settings & s ) {
|
|
std::map<std::string,int> map;
|
|
save_settings_to_map( map, s );
|
|
pugi::xml_document doc;
|
|
pugi::xml_node settings_node = doc.append_child( "settings" );
|
|
for ( const auto & setting : map ) {
|
|
settings_node.append_attribute( setting.first.c_str() ).set_value( setting.second );
|
|
}
|
|
std::ostringstream buf;
|
|
doc.save( buf );
|
|
xml = buf.str();
|
|
}
|
|
|
|
static void apply_options() {
|
|
if ( self->mod ) {
|
|
if ( !self->set_format_called ) {
|
|
// SetFormat will only be called once after loading a file.
|
|
// We cannot apply samplerate or numchannels changes afterwards during playback.
|
|
self->samplerate = self->settings.samplerate;
|
|
self->num_channels = self->settings.channels;
|
|
}
|
|
self->mod->set_repeat_count( self->settings.repeatcount );
|
|
self->mod->set_render_param( openmpt::module::RENDER_MASTERGAIN_MILLIBEL, self->settings.mastergain_millibel );
|
|
self->mod->set_render_param( openmpt::module::RENDER_STEREOSEPARATION_PERCENT, self->settings.stereoseparation );
|
|
self->mod->set_render_param( openmpt::module::RENDER_INTERPOLATIONFILTER_LENGTH, self->settings.interpolationfilterlength );
|
|
self->mod->set_render_param( openmpt::module::RENDER_VOLUMERAMPING_STRENGTH, self->settings.ramping );
|
|
self->mod->ctl_set_boolean( "render.resampler.emulate_amiga", self->settings.use_amiga_resampler ? true : false );
|
|
switch ( self->settings.amiga_filter_type ) {
|
|
case 0:
|
|
self->mod->ctl_set_text( "render.resampler.emulate_amiga_type", "auto" );
|
|
break;
|
|
case 1:
|
|
self->mod->ctl_set_text( "render.resampler.emulate_amiga_type", "unfiltered" );
|
|
break;
|
|
case 0xA500:
|
|
self->mod->ctl_set_text( "render.resampler.emulate_amiga_type", "a500" );
|
|
break;
|
|
case 0xA1200:
|
|
self->mod->ctl_set_text( "render.resampler.emulate_amiga_type", "a1200" );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void save_options() {
|
|
self->settings.save();
|
|
}
|
|
|
|
static void apply_and_save_options() {
|
|
apply_options();
|
|
save_options();
|
|
}
|
|
|
|
static void reset_options() {
|
|
self->settings = xmp_openmpt_settings();
|
|
self->settings.changed = apply_and_save_options;
|
|
self->settings.load();
|
|
}
|
|
|
|
// get config (return size of config data) (OPTIONAL)
|
|
static DWORD WINAPI openmpt_GetConfig( void * config ) {
|
|
std::string xml;
|
|
save_settings_to_xml( xml, self->settings );
|
|
if ( config ) {
|
|
std::memcpy( config, xml.c_str(), xml.length() + 1 );
|
|
}
|
|
return xml.length() + 1;
|
|
}
|
|
|
|
// apply config (OPTIONAL)
|
|
static void WINAPI openmpt_SetConfig( void * config, DWORD size ) {
|
|
reset_options();
|
|
if ( config ) {
|
|
load_settings_from_xml( self->settings, std::string( (char*)config, (char*)config + size ) );
|
|
apply_options();
|
|
}
|
|
}
|
|
|
|
static void WINAPI ShortcutHandler( DWORD id ) {
|
|
if ( !self->mod ) {
|
|
return;
|
|
}
|
|
|
|
bool tempo_changed = false, pitch_changed = false;
|
|
switch ( id ) {
|
|
case openmpt_shortcut_tempo_decrease: self->tempo_factor--; tempo_changed = true; break;
|
|
case openmpt_shortcut_tempo_increase: self->tempo_factor++; tempo_changed = true; break;
|
|
case openmpt_shortcut_pitch_decrease: self->pitch_factor--; pitch_changed = true; break;
|
|
case openmpt_shortcut_pitch_increase: self->pitch_factor++; pitch_changed = true; break;
|
|
case openmpt_shortcut_switch_interpolation:
|
|
self->settings.interpolationfilterlength *= 2;
|
|
if ( self->settings.interpolationfilterlength > 8 ) {
|
|
self->settings.interpolationfilterlength = 1;
|
|
}
|
|
apply_and_save_options();
|
|
const char *s = nullptr;
|
|
switch ( self->settings.interpolationfilterlength )
|
|
{
|
|
case 1: s = "Interpolation: Off"; break;
|
|
case 2: s = "Interpolation: Linear"; break;
|
|
case 4: s = "Interpolation: Cubic"; break;
|
|
case 8: s = "Interpolation: Polyphase"; break;
|
|
}
|
|
if ( s ) {
|
|
xmpfmisc->ShowBubble( s, 0 );
|
|
}
|
|
break;
|
|
}
|
|
|
|
self->tempo_factor = std::min( 48, std::max( -48, self->tempo_factor ) );
|
|
self->pitch_factor = std::min( 48, std::max( -48, self->pitch_factor ) );
|
|
const double tempo_factor = std::pow( 2.0, self->tempo_factor / 24.0 );
|
|
const double pitch_factor = std::pow( 2.0, self->pitch_factor / 24.0 );
|
|
|
|
if ( tempo_changed ) {
|
|
std::ostringstream s;
|
|
s << "Tempo: " << static_cast<std::int32_t>( 100.0 * tempo_factor ) << "%";
|
|
xmpfmisc->ShowBubble( s.str().c_str(), 0 );
|
|
} else if ( pitch_changed) {
|
|
std::ostringstream s;
|
|
s << "Pitch: ";
|
|
if ( self->pitch_factor > 0 )
|
|
s << "+";
|
|
else if ( self->pitch_factor == 0 )
|
|
s << "+/-";
|
|
s << (self->pitch_factor * 0.5) << " semitones";
|
|
xmpfmisc->ShowBubble( s.str().c_str(), 0 );
|
|
}
|
|
|
|
openmpt::ext::interactive *interactive = static_cast<openmpt::ext::interactive *>( self->mod->get_interface( openmpt::ext::interactive_id ) );
|
|
interactive->set_tempo_factor( tempo_factor );
|
|
interactive->set_pitch_factor( pitch_factor );
|
|
xmpfin->SetLength( static_cast<float>( self->mod->get_duration_seconds() / tempo_factor ), TRUE );
|
|
}
|
|
|
|
|
|
static double timeinfo_position = 0.0;
|
|
struct timeinfo {
|
|
bool valid;
|
|
double seconds;
|
|
std::int32_t pattern;
|
|
std::int32_t row;
|
|
};
|
|
static std::queue<timeinfo> timeinfos;
|
|
static void reset_timeinfos( double position = 0.0 ) {
|
|
while ( !timeinfos.empty() ) {
|
|
timeinfos.pop();
|
|
}
|
|
timeinfo_position = position;
|
|
}
|
|
static void update_timeinfos( std::int32_t samplerate, std::int32_t count ) {
|
|
timeinfo_position += (double)count / (double)samplerate;
|
|
timeinfo info;
|
|
info.valid = true;
|
|
info.seconds = timeinfo_position;
|
|
info.pattern = self->mod->get_current_pattern();
|
|
info.row = self->mod->get_current_row();
|
|
timeinfos.push( info );
|
|
}
|
|
|
|
static timeinfo current_timeinfo;
|
|
|
|
static timeinfo lookup_timeinfo( double seconds ) {
|
|
timeinfo info = current_timeinfo;
|
|
#if 0
|
|
info.seconds = timeinfo_position;
|
|
info.pattern = self->mod->get_current_pattern();
|
|
info.row = self->mod->get_current_row();
|
|
#endif
|
|
while ( timeinfos.size() > 0 && timeinfos.front().seconds <= seconds ) {
|
|
info = timeinfos.front();
|
|
timeinfos.pop();
|
|
}
|
|
current_timeinfo = info;
|
|
return current_timeinfo;
|
|
}
|
|
|
|
static void clear_current_timeinfo() {
|
|
current_timeinfo = timeinfo();
|
|
}
|
|
|
|
static void WINAPI openmpt_About( HWND win ) {
|
|
std::ostringstream about;
|
|
about << SHORT_TITLE << " version " << openmpt::string::get( "library_version" ) << " " << "(built " << openmpt::string::get( "build" ) << ")" << std::endl;
|
|
about << " Copyright (c) 2013-2022 OpenMPT Project Developers and Contributors (https://lib.openmpt.org/)" << std::endl;
|
|
about << " OpenMPT version " << openmpt::string::get( "core_version" ) << std::endl;
|
|
about << std::endl;
|
|
about << openmpt::string::get( "contact" ) << std::endl;
|
|
about << std::endl;
|
|
about << "Show full credits?" << std::endl;
|
|
if ( MessageBox( win, StringToWINAPI( StringDecode( about.str(), CP_UTF8 ) ).c_str(), TEXT(SHORT_TITLE), MB_ICONINFORMATION | MB_YESNOCANCEL | MB_DEFBUTTON1 ) != IDYES ) {
|
|
return;
|
|
}
|
|
std::ostringstream credits;
|
|
credits << openmpt::string::get( "credits" );
|
|
credits << "Additional thanks to:" << std::endl;
|
|
credits << std::endl;
|
|
credits << "Arseny Kapoulkine for pugixml" << std::endl;
|
|
credits << "https://pugixml.org/" << std::endl;
|
|
#if 1
|
|
libopenmpt::plugin::gui_show_file_info( win, TEXT(SHORT_TITLE), StringToWINAPI( StringReplace( StringDecode( credits.str(), CP_UTF8 ), L"\n", L"\r\n" ) ) );
|
|
#else
|
|
MessageBox( win, StringToWINAPI( StringReplace( StringDecode( credits.str(), CP_UTF8 ), L"\n", L"\r\n" ) ).c_str(), TEXT(SHORT_TITLE), MB_OK );
|
|
#endif
|
|
}
|
|
|
|
static void WINAPI openmpt_Config( HWND win ) {
|
|
#if 1
|
|
libopenmpt::plugin::gui_edit_settings( &self->settings, win, TEXT(SHORT_TITLE) );
|
|
#else
|
|
static_cast<void>(win);
|
|
#endif
|
|
apply_and_save_options();
|
|
}
|
|
|
|
#ifdef USE_XMPLAY_FILE_IO
|
|
|
|
#ifdef USE_XMPLAY_ISTREAM
|
|
|
|
class xmplay_streambuf : public std::streambuf {
|
|
public:
|
|
explicit xmplay_streambuf( XMPFILE & file );
|
|
private:
|
|
int_type underflow() override;
|
|
xmplay_streambuf( const xmplay_streambuf & );
|
|
xmplay_streambuf & operator = ( const xmplay_streambuf & );
|
|
private:
|
|
XMPFILE & file;
|
|
static const std::size_t put_back = 4096;
|
|
static const std::size_t buf_size = 65536;
|
|
std::vector<char> buffer;
|
|
}; // class xmplay_streambuf
|
|
|
|
xmplay_streambuf::xmplay_streambuf( XMPFILE & file_ ) : file(file_), buffer(buf_size) {
|
|
char * end = &buffer.front() + buffer.size();
|
|
setg( end, end, end );
|
|
}
|
|
|
|
std::streambuf::int_type xmplay_streambuf::underflow() {
|
|
if ( gptr() < egptr() ) {
|
|
return traits_type::to_int_type( *gptr() );
|
|
}
|
|
char * base = &buffer.front();
|
|
char * start = base;
|
|
if ( eback() == base ) {
|
|
std::size_t put_back_count = std::min( put_back, static_cast<std::size_t>( egptr() - base ) );
|
|
std::memmove( base, egptr() - put_back_count, put_back_count );
|
|
start += put_back_count;
|
|
}
|
|
std::size_t n = xmpffile->Read( file, start, buffer.size() - ( start - base ) );
|
|
if ( n == 0 ) {
|
|
return traits_type::eof();
|
|
}
|
|
setg( base, start, start + n );
|
|
return traits_type::to_int_type( *gptr() );
|
|
}
|
|
|
|
class xmplay_istream : public std::istream {
|
|
private:
|
|
xmplay_streambuf buf;
|
|
private:
|
|
xmplay_istream( const xmplay_istream & );
|
|
xmplay_istream & operator = ( const xmplay_istream & );
|
|
public:
|
|
xmplay_istream( XMPFILE & file ) : std::istream(&buf), buf(file) {
|
|
return;
|
|
}
|
|
~xmplay_istream() {
|
|
return;
|
|
}
|
|
}; // class xmplay_istream
|
|
|
|
// Stream for memory-based files (required for could_open_probability)
|
|
struct xmplay_membuf : std::streambuf {
|
|
xmplay_membuf( const char * base, size_t size ) {
|
|
char* p( const_cast<char *>( base ) );
|
|
setg(p, p, p + size);
|
|
}
|
|
};
|
|
|
|
struct xmplay_imemstream : virtual xmplay_membuf, std::istream {
|
|
xmplay_imemstream( const char * base, size_t size )
|
|
: xmplay_membuf( base, size )
|
|
, std::istream( static_cast<std::streambuf *>(this)) {
|
|
return;
|
|
}
|
|
};
|
|
|
|
#else // !USE_XMPLAY_ISTREAM
|
|
|
|
static std::vector<char> read_XMPFILE_vector( XMPFILE & file ) {
|
|
std::vector<char> data( xmpffile->GetSize( file ) );
|
|
if ( data.size() != xmpffile->Read( file, data.data(), data.size() ) ) {
|
|
return std::vector<char>();
|
|
}
|
|
return data;
|
|
}
|
|
|
|
static std::string read_XMPFILE_string( XMPFILE & file ) {
|
|
std::vector<char> data = read_XMPFILE_vector( file );
|
|
return std::string( data.begin(), data.end() );
|
|
}
|
|
|
|
#endif // USE_XMPLAY_ISTREAM
|
|
|
|
#endif // USE_XMPLAY_FILE_IO
|
|
|
|
static std::string string_replace( std::string str, const std::string & oldStr, const std::string & newStr ) {
|
|
std::size_t pos = 0;
|
|
while((pos = str.find(oldStr, pos)) != std::string::npos)
|
|
{
|
|
str.replace(pos, oldStr.length(), newStr);
|
|
pos += newStr.length();
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static void write_xmplay_string( char * dst, std::string src ) {
|
|
// xmplay buffers are ~40kB, be conservative and truncate at 32kB-2
|
|
if ( !dst ) {
|
|
return;
|
|
}
|
|
src = src.substr( 0, (1<<15) - 2 );
|
|
std::strcpy( dst, src.c_str() );
|
|
}
|
|
|
|
static std::string extract_date( const openmpt::module & mod ) {
|
|
std::string result = mod.get_metadata("date");
|
|
if ( result.empty() ) {
|
|
// Search the sample, instrument and message texts for possible release years.
|
|
// We'll look for things that may vaguely resemble a release year, such as 4-digit numbers
|
|
// or 2-digit numbers with a leading apostrophe. Generally, only years between
|
|
// 1988 (release of Ultimate SoundTracker) and the current year + 1 (safety margin) will
|
|
// be considered.
|
|
std::string s = " " + mod.get_metadata("message");
|
|
auto names = mod.get_sample_names();
|
|
for ( const auto & name : names ) {
|
|
s += " " + name;
|
|
}
|
|
names = mod.get_instrument_names();
|
|
for ( const auto & name : names ) {
|
|
s += " " + name;
|
|
}
|
|
s += " ";
|
|
|
|
int32_t best_year = 0;
|
|
|
|
SYSTEMTIME time;
|
|
GetSystemTime( &time );
|
|
const int32_t current_year = time.wYear + 1;
|
|
|
|
#define MPT_NUMERIC( x ) ( ( x >= '0' ) && ( x <= '9' ) )
|
|
for ( auto i = s.cbegin(); i != s.cend(); ++i ) {
|
|
std::size_t len = s.length();
|
|
std::size_t idx = i - s.begin();
|
|
std::size_t remaining = len - idx;
|
|
if ( ( remaining >= 6 ) && !MPT_NUMERIC( i[0] ) && MPT_NUMERIC( i[1] ) && MPT_NUMERIC( i[2] ) && MPT_NUMERIC( i[3] ) && MPT_NUMERIC( i[4] ) && !MPT_NUMERIC( i[5] ) ) {
|
|
// Four-digit year
|
|
const int32_t year = ( i[1] - '0' ) * 1000 + ( i[2] - '0' ) * 100 + ( i[3] - '0' ) * 10 + ( i[4] - '0' );
|
|
if ( year >= 1988 && year <= current_year ) {
|
|
best_year = std::max( year, best_year );
|
|
}
|
|
} else if ( ( remaining >= 4 ) && ( i[0] == '\'' ) && MPT_NUMERIC( i[1] ) && MPT_NUMERIC( i[2] ) && !MPT_NUMERIC( i[3] ) ) {
|
|
// Apostrophe + two-digit year
|
|
const int32_t year = ( i[1] - '0' ) * 10 + ( i[2] - '0' );
|
|
if ( year >= 88 && year <= 99 ) {
|
|
best_year = std::max( 1900 + year, best_year );
|
|
} else if ( year >= 00 && ( 2000 + year ) <= current_year ) {
|
|
best_year = std::max( 2000 + year, best_year );
|
|
}
|
|
}
|
|
}
|
|
#undef MPT_NUMERIC
|
|
|
|
if ( best_year != 0 ) {
|
|
std::ostringstream os;
|
|
os << best_year;
|
|
result = os.str();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static void append_xmplay_tag( std::string & tags, const std::string & tag, const std::string & val ) {
|
|
if ( tag.empty() ) {
|
|
return;
|
|
}
|
|
if ( val.empty() ) {
|
|
return;
|
|
}
|
|
tags.append( tag );
|
|
tags.append( 1, '\0' );
|
|
tags.append( val );
|
|
tags.append( 1, '\0' );
|
|
}
|
|
|
|
static char * build_xmplay_tags( const openmpt::module & mod, int32_t subsong = -1 ) {
|
|
std::string tags;
|
|
const std::string title = mod.get_metadata("title");
|
|
|
|
const auto subsong_names = mod.get_subsong_names();
|
|
auto first_subsong = subsong_names.cbegin(), last_subsong = subsong_names.cend();
|
|
if ( subsong >= 0 && static_cast<size_t>( subsong ) < subsong_names.size() ) {
|
|
first_subsong += subsong;
|
|
last_subsong = first_subsong + 1;
|
|
} else
|
|
{
|
|
last_subsong = first_subsong + 1;
|
|
}
|
|
|
|
for ( auto subsong_name = first_subsong; subsong_name != last_subsong; subsong_name++ ) {
|
|
append_xmplay_tag( tags, "filetype", convert_to_native( StringUpperCase( mod.get_metadata( "type" ) ) ) );
|
|
append_xmplay_tag( tags, "title", convert_to_native( ( subsong_name->empty() || subsong == -1 ) ? title : *subsong_name ) );
|
|
append_xmplay_tag( tags, "artist", convert_to_native( mod.get_metadata( "artist" ) ) );
|
|
append_xmplay_tag( tags, "album", convert_to_native( mod.get_metadata( "xmplay-album" ) ) ); // todo, libopenmpt does not support that
|
|
append_xmplay_tag( tags, "date", convert_to_native( extract_date( mod ) ) );
|
|
append_xmplay_tag( tags, "track", convert_to_native( mod.get_metadata( "xmplay-tracknumber" ) ) ); // todo, libopenmpt does not support that
|
|
append_xmplay_tag( tags, "genre", convert_to_native( mod.get_metadata( "xmplay-genre" ) ) ); // todo, libopenmpt does not support that
|
|
append_xmplay_tag( tags, "comment", convert_to_native( mod.get_metadata( "message" ) ) );
|
|
tags.append( 1, '\0' );
|
|
}
|
|
char * result = static_cast<char*>( xmpfmisc->Alloc( tags.size() ) );
|
|
if ( !result ) {
|
|
return nullptr;
|
|
}
|
|
std::copy( tags.data(), tags.data() + tags.size(), result );
|
|
return result;
|
|
}
|
|
|
|
static float * build_xmplay_length( const openmpt::module & /* mod */ ) {
|
|
float * result = static_cast<float*>( xmpfmisc->Alloc( sizeof( float ) * self->subsong_lengths.size() ) );
|
|
if ( !result ) {
|
|
return nullptr;
|
|
}
|
|
for ( std::size_t i = 0; i < self->subsong_lengths.size(); ++i ) {
|
|
result[i] = self->subsong_lengths[i];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void clear_xmplay_string( char * str ) {
|
|
if ( !str ) {
|
|
return;
|
|
}
|
|
str[0] = '\0';
|
|
}
|
|
|
|
static std::string sanitize_xmplay_info_string( const std::string & str ) {
|
|
std::string result;
|
|
result.reserve(str.size());
|
|
for ( auto c : str ) {
|
|
switch ( c ) {
|
|
case '\0':
|
|
case '\t':
|
|
case '\r':
|
|
case '\n':
|
|
break;
|
|
default:
|
|
result.push_back( c );
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static std::string sanitize_xmplay_multiline_info_string( const std::string & str ) {
|
|
std::string result;
|
|
result.reserve(str.size());
|
|
for ( auto c : str ) {
|
|
switch ( c ) {
|
|
case '\0':
|
|
case '\t':
|
|
case '\r':
|
|
break;
|
|
case '\n':
|
|
result.push_back( '\r' );
|
|
result.push_back( '\t' );
|
|
break;
|
|
default:
|
|
result.push_back( c );
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static std::string sanitize_xmplay_multiline_string( const std::string & str ) {
|
|
std::string result;
|
|
result.reserve(str.size());
|
|
for ( auto c : str ) {
|
|
switch ( c ) {
|
|
case '\0':
|
|
case '\t':
|
|
break;
|
|
default:
|
|
result.push_back( c );
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// check if a file is playable by this plugin
|
|
// more thorough checks can be saved for the GetFileInfo and Open functions
|
|
static BOOL WINAPI openmpt_CheckFile( const char * filename, XMPFILE file ) {
|
|
static_cast<void>( filename );
|
|
try {
|
|
#ifdef USE_XMPLAY_FILE_IO
|
|
#ifdef USE_XMPLAY_ISTREAM
|
|
switch ( xmpffile->GetType( file ) ) {
|
|
case XMPFILE_TYPE_MEMORY:
|
|
{
|
|
xmplay_imemstream s( reinterpret_cast<const char *>( xmpffile->GetMemory( file ) ), xmpffile->GetSize( file ) );
|
|
return ( openmpt::probe_file_header( openmpt::probe_file_header_flags_default2, s ) == openmpt::probe_file_header_result_success ) ? TRUE : FALSE;
|
|
}
|
|
break;
|
|
case XMPFILE_TYPE_FILE:
|
|
case XMPFILE_TYPE_NETFILE:
|
|
case XMPFILE_TYPE_NETSTREAM:
|
|
default:
|
|
{
|
|
xmplay_istream s( file );
|
|
return ( openmpt::probe_file_header( openmpt::probe_file_header_flags_default2, s ) == openmpt::probe_file_header_result_success ) ? TRUE : FALSE;
|
|
}
|
|
break;
|
|
}
|
|
#else
|
|
if ( xmpffile->GetType( file ) == XMPFILE_TYPE_MEMORY ) {
|
|
std::string data( reinterpret_cast<const char*>( xmpffile->GetMemory( file ) ), xmpffile->GetSize( file ) );
|
|
std::istringstream s( data );
|
|
return ( openmpt::probe_file_header( openmpt::probe_file_header_flags_default2, s ) == openmpt::probe_file_header_result_success ) ? TRUE : FALSE;
|
|
} else {
|
|
std::string data = read_XMPFILE_string( file );
|
|
std::istringstream s(data);
|
|
return ( openmpt::probe_file_header( openmpt::probe_file_header_flags_default2, s ) == openmpt::probe_file_header_result_success ) ? TRUE : FALSE;
|
|
}
|
|
#endif
|
|
#else
|
|
std::ifstream s( filename, std::ios_base::binary );
|
|
return ( openmpt::probe_file_header( openmpt::probe_file_header_flags_default2, s ) == openmpt::probe_file_header_result_success ) ? TRUE : FALSE;
|
|
#endif
|
|
} catch ( ... ) {
|
|
return FALSE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static DWORD WINAPI openmpt_GetFileInfo( const char * filename, XMPFILE file, float * * length, char * * tags ) {
|
|
static_cast<void>( filename );
|
|
try {
|
|
std::map< std::string, std::string > ctls
|
|
{
|
|
{ "load.skip_plugins", "1" },
|
|
{ "load.skip_samples", "1" },
|
|
};
|
|
#ifdef USE_XMPLAY_FILE_IO
|
|
#ifdef USE_XMPLAY_ISTREAM
|
|
switch ( xmpffile->GetType( file ) ) {
|
|
case XMPFILE_TYPE_MEMORY:
|
|
{
|
|
openmpt::module mod( xmpffile->GetMemory( file ), xmpffile->GetSize( file ), std::clog, ctls );
|
|
if ( length ) {
|
|
*length = build_xmplay_length( mod );
|
|
}
|
|
if ( tags ) {
|
|
*tags = build_xmplay_tags( mod );
|
|
}
|
|
}
|
|
break;
|
|
case XMPFILE_TYPE_FILE:
|
|
case XMPFILE_TYPE_NETFILE:
|
|
case XMPFILE_TYPE_NETSTREAM:
|
|
default:
|
|
{
|
|
xmplay_istream s( file );
|
|
openmpt::module mod( s, std::clog, ctls );
|
|
if ( length ) {
|
|
*length = build_xmplay_length( mod );
|
|
}
|
|
if ( tags ) {
|
|
*tags = build_xmplay_tags( mod );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#else
|
|
if ( xmpffile->GetType( file ) == XMPFILE_TYPE_MEMORY ) {
|
|
openmpt::module mod( xmpffile->GetMemory( file ), xmpffile->GetSize( file ), std::clog, ctls );
|
|
if ( length ) {
|
|
*length = build_xmplay_length( mod );
|
|
}
|
|
if ( tags ) {
|
|
*tags = build_xmplay_tags( mod );
|
|
}
|
|
} else {
|
|
openmpt::module mod( read_XMPFILE_vector( file ), std::clog, ctls );
|
|
if ( length ) {
|
|
*length = build_xmplay_length( mod );
|
|
}
|
|
if ( tags ) {
|
|
*tags = build_xmplay_tags( mod );
|
|
}
|
|
}
|
|
#endif
|
|
#else
|
|
std::ifstream s( filename, std::ios_base::binary );
|
|
openmpt::module mod( s, std::clog, ctls );
|
|
if ( length ) {
|
|
*length = build_xmplay_length( mod );
|
|
}
|
|
if ( tags ) {
|
|
*tags = build_xmplay_tags( mod );
|
|
}
|
|
#endif
|
|
} catch ( ... ) {
|
|
if ( length ) *length = nullptr;
|
|
if ( tags ) *tags = nullptr;
|
|
return 0;
|
|
}
|
|
return self->subsong_lengths.size() + XMPIN_INFO_NOSUBTAGS;
|
|
}
|
|
|
|
// open a file for playback
|
|
// return: 0=failed, 1=success, 2=success and XMPlay can close the file
|
|
static DWORD WINAPI openmpt_Open( const char * filename, XMPFILE file ) {
|
|
static_cast<void>( filename );
|
|
xmpopenmpt_lock guard;
|
|
reset_options();
|
|
try {
|
|
std::map< std::string, std::string > ctls
|
|
{
|
|
{ "seek.sync_samples", "1" },
|
|
{ "play.at_end", "continue" },
|
|
};
|
|
self->delete_mod();
|
|
#ifdef USE_XMPLAY_FILE_IO
|
|
#ifdef USE_XMPLAY_ISTREAM
|
|
switch ( xmpffile->GetType( file ) ) {
|
|
case XMPFILE_TYPE_MEMORY:
|
|
self->mod = new openmpt::module_ext( xmpffile->GetMemory( file ), xmpffile->GetSize( file ), std::clog, ctls );
|
|
break;
|
|
case XMPFILE_TYPE_FILE:
|
|
case XMPFILE_TYPE_NETFILE:
|
|
case XMPFILE_TYPE_NETSTREAM:
|
|
default:
|
|
{
|
|
xmplay_istream s( file );
|
|
self->mod = new openmpt::module_ext( s, std::clog, ctls );
|
|
}
|
|
break;
|
|
}
|
|
#else
|
|
if ( xmpffile->GetType( file ) == XMPFILE_TYPE_MEMORY ) {
|
|
self->mod = new openmpt::module_ext( xmpffile->GetMemory( file ), xmpffile->GetSize( file ), std::clog, ctls );
|
|
} else {
|
|
self->mod = new openmpt::module_ext( read_XMPFILE_vector( file ), std::clog, ctls );
|
|
}
|
|
#endif
|
|
#else
|
|
self->mod = new openmpt::module_ext( std::ifstream( filename, std::ios_base::binary ), std::clog, ctls );
|
|
#endif
|
|
self->on_new_mod();
|
|
clear_current_timeinfo();
|
|
reset_timeinfos();
|
|
apply_options();
|
|
|
|
std::int32_t num_subsongs = self->mod->get_num_subsongs();
|
|
self->subsong_lengths.resize( num_subsongs );
|
|
for ( std::int32_t i = 0; i < num_subsongs; ++i ) {
|
|
self->mod->select_subsong( i );
|
|
self->subsong_lengths[i] = static_cast<float>( self->mod->get_duration_seconds() );
|
|
}
|
|
self->subsong_names = self->mod->get_subsong_names();
|
|
self->mod->select_subsong( 0 );
|
|
self->tempo_factor = 0;
|
|
self->pitch_factor = 0;
|
|
|
|
xmpfin->SetLength( self->subsong_lengths[0], TRUE );
|
|
return 2;
|
|
} catch ( ... ) {
|
|
self->delete_mod();
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// close the file
|
|
static void WINAPI openmpt_Close() {
|
|
xmpopenmpt_lock guard;
|
|
self->delete_mod();
|
|
}
|
|
|
|
// set the sample format (in=user chosen format, out=file format if different)
|
|
static void WINAPI openmpt_SetFormat( XMPFORMAT * form ) {
|
|
if ( !form ) {
|
|
return;
|
|
}
|
|
// SetFormat will only be called once after loading a file.
|
|
// We cannot apply samplerate or numchannels changes afterwards during playback.
|
|
self->set_format_called = true;
|
|
if ( !self->mod ) {
|
|
form->rate = 0;
|
|
form->chan = 0;
|
|
form->res = 0;
|
|
return;
|
|
}
|
|
if ( self->settings.samplerate != 0 ) {
|
|
form->rate = self->samplerate;
|
|
} else {
|
|
if ( form->rate > 0 ) {
|
|
self->samplerate = form->rate;
|
|
} else {
|
|
form->rate = 48000;
|
|
self->samplerate = 48000;
|
|
}
|
|
}
|
|
if ( self->settings.channels != 0 ) {
|
|
form->chan = self->num_channels;
|
|
} else {
|
|
if ( form->chan > 0 ) {
|
|
if ( form->chan > 2 ) {
|
|
form->chan = 4;
|
|
self->num_channels = 4;
|
|
} else {
|
|
self->num_channels = form->chan;
|
|
}
|
|
} else {
|
|
form->chan = 2;
|
|
self->num_channels = 2;
|
|
}
|
|
}
|
|
form->res = 4; // float
|
|
}
|
|
|
|
// get the tags
|
|
static char * WINAPI openmpt_GetTags() {
|
|
if ( !self->mod ) {
|
|
char * tags = static_cast<char*>( xmpfmisc->Alloc( 1 ) );
|
|
tags[0] = '\0';
|
|
return tags;
|
|
}
|
|
return build_xmplay_tags( *self->mod, std::max( 0, self->mod->get_selected_subsong() ) );
|
|
}
|
|
|
|
// get the main panel info text
|
|
static void WINAPI openmpt_GetInfoText( char * format, char * length ) {
|
|
if ( !self->mod ) {
|
|
clear_xmplay_string( format );
|
|
clear_xmplay_string( length );
|
|
return;
|
|
}
|
|
if ( format ) {
|
|
std::ostringstream str;
|
|
str
|
|
<< StringUpperCase( self->mod->get_metadata("type") )
|
|
<< " - "
|
|
<< self->mod->get_num_channels() << " ch"
|
|
<< " - "
|
|
<< "(via " << SHORTER_TITLE << ")"
|
|
;
|
|
write_xmplay_string( format, sanitize_xmplay_info_string( str.str() ) );
|
|
}
|
|
if ( length ) {
|
|
std::ostringstream str;
|
|
str
|
|
<< length
|
|
<< " - "
|
|
<< self->mod->get_num_orders() << " orders"
|
|
;
|
|
write_xmplay_string( length, sanitize_xmplay_info_string( str.str() ) );
|
|
}
|
|
}
|
|
|
|
// get text for "General" info window
|
|
// separate headings and values with a tab (\t), end each line with a carriage-return (\r)
|
|
static void WINAPI openmpt_GetGeneralInfo( char * buf ) {
|
|
if ( !self->mod ) {
|
|
clear_xmplay_string( buf );
|
|
return;
|
|
}
|
|
std::ostringstream str;
|
|
str << "\r";
|
|
bool metadatainfo = false;
|
|
if ( !self->mod->get_metadata("artist").empty() ) {
|
|
metadatainfo = true;
|
|
str << "Artist" << "\t" << sanitize_xmplay_info_string( self->mod->get_metadata("artist") ) << "\r";
|
|
}
|
|
const std::string date = extract_date( *self->mod );
|
|
if ( !date.empty() ) {
|
|
metadatainfo = true;
|
|
str << "Date" << "\t" << sanitize_xmplay_info_string( date ) << "\r";
|
|
}
|
|
if ( metadatainfo ) {
|
|
str << "\r";
|
|
}
|
|
str << "Format" << "\t" << sanitize_xmplay_info_string( self->mod->get_metadata("type") ) << " (" << sanitize_xmplay_info_string( self->mod->get_metadata("type_long") ) << ")" << "\r";
|
|
if ( !self->mod->get_metadata("originaltype").empty() ) {
|
|
str << "Original Type" << "\t" << sanitize_xmplay_info_string( self->mod->get_metadata("originaltype") ) << " (" << sanitize_xmplay_info_string( self->mod->get_metadata("originaltype_long") ) << ")" << "\r";
|
|
}
|
|
if ( !self->mod->get_metadata("container").empty() ) {
|
|
str << "Container" << "\t" << sanitize_xmplay_info_string( self->mod->get_metadata("container") ) << " (" << sanitize_xmplay_info_string( self->mod->get_metadata("container_long") ) << ")" << "\r";
|
|
}
|
|
str
|
|
<< "Channels" << "\t" << self->mod->get_num_channels() << "\r"
|
|
<< "Orders" << "\t" << self->mod->get_num_orders() << "\r"
|
|
<< "Patterns" << "\t" << self->mod->get_num_patterns() << "\r";
|
|
if ( self->mod->get_num_instruments() != 0 ) {
|
|
str << "Instruments" << "\t" << self->mod->get_num_instruments() << "\r";
|
|
}
|
|
str << "Samples" << "\t" << self->mod->get_num_samples() << "\r";
|
|
|
|
if( !self->single_subsong_mode && self->subsong_lengths.size() > 1 ) {
|
|
for ( std::size_t i = 0; i < self->subsong_lengths.size(); ++i ) {
|
|
str << ( i == 0 ? "Subsongs\t" : "\t" ) << (i + 1) << ". " << seconds_to_string( self->subsong_lengths[i]) << " " << self->subsong_names[i] << "\r";
|
|
}
|
|
}
|
|
|
|
str
|
|
<< "\r"
|
|
<< "Tracker" << "\t" << sanitize_xmplay_info_string( self->mod->get_metadata("tracker") ) << "\r"
|
|
<< "Player" << "\t" << "xmp-openmpt" << " version " << openmpt::string::get( "library_version" ) << "\r"
|
|
;
|
|
std::string warnings = self->mod->get_metadata("warnings");
|
|
if ( !warnings.empty() ) {
|
|
str << "Warnings" << "\t" << sanitize_xmplay_multiline_info_string( warnings ) << "\r";
|
|
}
|
|
str << "\r";
|
|
write_xmplay_string( buf, str.str() );
|
|
}
|
|
|
|
// get text for "Message" info window
|
|
// separate tag names and values with a tab (\t), and end each line with a carriage-return (\r)
|
|
static void WINAPI openmpt_GetMessage( char * buf ) {
|
|
if ( !self->mod ) {
|
|
clear_xmplay_string( buf );
|
|
return;
|
|
}
|
|
write_xmplay_string( buf, convert_to_native( sanitize_xmplay_multiline_string( string_replace( self->mod->get_metadata("message"), "\n", "\r" ) ) ) );
|
|
}
|
|
|
|
// Seek to a position (in granularity units)
|
|
// return the new position in seconds (-1 = failed)
|
|
static double WINAPI openmpt_SetPosition( DWORD pos ) {
|
|
if ( !self->mod ) {
|
|
return -1.0;
|
|
}
|
|
if ( pos == static_cast<DWORD>(static_cast<LONG>(XMPIN_POS_LOOP)) ) {
|
|
// If the time of the loop start position is known, that should be returned, otherwise -2 can be returned to let the time run on.
|
|
// There is currently no way to easily figure out at which time the loop restarts.
|
|
return -2;
|
|
} else if ( pos == static_cast<DWORD>(static_cast<LONG>(XMPIN_POS_AUTOLOOP)) ) {
|
|
// In the auto-looping case, the function should only loop when a loop has been detected, and otherwise return -1
|
|
// If the time of the loop start position is known, that should be returned, otherwise -2 can be returned to let the time run on.
|
|
// There is currently no way to easily figure out at which time the loop restarts.
|
|
return -2;
|
|
}
|
|
if ( pos & XMPIN_POS_SUBSONG ) {
|
|
self->single_subsong_mode = ( pos & XMPIN_POS_SUBSONG1 ) != 0;
|
|
const int32_t subsong = pos & 0xffff;
|
|
try {
|
|
self->mod->select_subsong( subsong );
|
|
} catch ( ... ) {
|
|
return 0.0;
|
|
}
|
|
openmpt::ext::interactive *interactive = static_cast<openmpt::ext::interactive *>( self->mod->get_interface( openmpt::ext::interactive_id ) );
|
|
xmpfin->SetLength( static_cast<float>( self->subsong_lengths[ subsong ] / interactive->get_tempo_factor() ), TRUE );
|
|
xmpfin->UpdateTitle( nullptr );
|
|
reset_timeinfos( 0 );
|
|
return 0.0;
|
|
}
|
|
double new_position = self->mod->set_position_seconds( static_cast<double>( pos ) * 0.001 );
|
|
reset_timeinfos( new_position );
|
|
return new_position;
|
|
}
|
|
|
|
// Get the seeking granularity in seconds
|
|
static double WINAPI openmpt_GetGranularity() {
|
|
return 0.001;
|
|
}
|
|
|
|
// get some sample data, always floating-point
|
|
// count=number of floats to write (not bytes or samples)
|
|
// return number of floats written. if it's less than requested, playback is ended...
|
|
// so wait for more if there is more to come (use CheckCancel function to check if user wants to cancel)
|
|
static DWORD WINAPI openmpt_Process( float * dstbuf, DWORD count ) {
|
|
xmpopenmpt_lock guard;
|
|
if ( !self->mod || self->num_channels == 0 ) {
|
|
return 0;
|
|
}
|
|
update_timeinfos( self->samplerate, 0 );
|
|
std::size_t frames = count / self->num_channels;
|
|
std::size_t frames_to_render = frames;
|
|
std::size_t frames_rendered = 0;
|
|
while ( frames_to_render > 0 ) {
|
|
std::size_t frames_chunk = std::min( frames_to_render, static_cast<std::size_t>( ( self->samplerate + 99 ) / 100 ) ); // 100 Hz timing info update interval
|
|
switch ( self->num_channels ) {
|
|
case 1:
|
|
{
|
|
frames_chunk = self->mod->read( self->samplerate, frames_chunk, dstbuf );
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
frames_chunk = self->mod->read_interleaved_stereo( self->samplerate, frames_chunk, dstbuf );
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
frames_chunk = self->mod->read_interleaved_quad( self->samplerate, frames_chunk, dstbuf );
|
|
}
|
|
break;
|
|
}
|
|
dstbuf += frames_chunk * self->num_channels;
|
|
if ( frames_chunk == 0 ) {
|
|
break;
|
|
}
|
|
update_timeinfos( self->samplerate, frames_chunk );
|
|
frames_to_render -= frames_chunk;
|
|
frames_rendered += frames_chunk;
|
|
}
|
|
if ( frames_rendered == 0 ) {
|
|
return 0;
|
|
}
|
|
return frames_rendered * self->num_channels;
|
|
}
|
|
|
|
static void add_names( std::ostream & str, const std::string & title, const std::vector<std::string> & names, int display_offset ) {
|
|
if ( names.size() > 0 ) {
|
|
bool valid = false;
|
|
for ( std::size_t i = 0; i < names.size(); i++ ) {
|
|
if ( names[i] != "" ) {
|
|
valid = true;
|
|
}
|
|
}
|
|
if ( !valid ) {
|
|
return;
|
|
}
|
|
str << title << " Names:" << "\r";
|
|
for ( std::size_t i = 0; i < names.size(); i++ ) {
|
|
str << std::setfill('0') << std::setw(2) << (display_offset + i) << std::setw(0) << "\t" << convert_to_native( names[i] ) << "\r";
|
|
}
|
|
str << "\r";
|
|
}
|
|
}
|
|
|
|
static void WINAPI openmpt_GetSamples( char * buf ) {
|
|
if ( !self->mod ) {
|
|
clear_xmplay_string( buf );
|
|
return;
|
|
}
|
|
std::ostringstream str;
|
|
add_names( str, "Instrument", self->mod->get_instrument_names(), 1 );
|
|
add_names( str, "Sample", self->mod->get_sample_names(), 1 );
|
|
add_names( str, "Channel", self->mod->get_channel_names(), 1 );
|
|
add_names( str, "Order", self->mod->get_order_names(), 0 );
|
|
add_names( str, "Pattern", self->mod->get_pattern_names(), 0 );
|
|
write_xmplay_string( buf, str.str() );
|
|
}
|
|
|
|
static DWORD WINAPI openmpt_GetSubSongs( float * length ) {
|
|
*length = 0.0f;
|
|
for ( auto sub_length : self->subsong_lengths ) {
|
|
*length += sub_length;
|
|
}
|
|
|
|
return static_cast<DWORD>( self->subsong_lengths.size() );
|
|
}
|
|
|
|
enum ColorIndex
|
|
{
|
|
col_background = 0,
|
|
col_unknown,
|
|
col_text,
|
|
col_empty,
|
|
col_instr,
|
|
col_vol,
|
|
col_pitch,
|
|
col_global,
|
|
|
|
col_max
|
|
};
|
|
|
|
static ColorIndex effect_type_to_color_index( openmpt::ext::pattern_vis::effect_type effect_type ) {
|
|
switch ( effect_type ) {
|
|
case openmpt::ext::pattern_vis::effect_unknown: return col_unknown; break;
|
|
case openmpt::ext::pattern_vis::effect_general: return col_text ; break;
|
|
case openmpt::ext::pattern_vis::effect_global : return col_global ; break;
|
|
case openmpt::ext::pattern_vis::effect_volume : return col_vol ; break;
|
|
case openmpt::ext::pattern_vis::effect_panning: return col_instr ; break;
|
|
case openmpt::ext::pattern_vis::effect_pitch : return col_pitch ; break;
|
|
default: return col_unknown; break;
|
|
}
|
|
}
|
|
|
|
const struct Columns
|
|
{
|
|
int num_chars;
|
|
int color;
|
|
} pattern_columns[] = {
|
|
{ 3, col_text }, // C-5
|
|
{ 2, col_instr }, // 01
|
|
{ 3, col_vol }, // v64
|
|
{ 3, col_pitch }, // EFF
|
|
};
|
|
|
|
static const int max_cols = 4;
|
|
|
|
static void assure_width( std::string & str, std::size_t width ) {
|
|
if ( str.length() == width ) {
|
|
return;
|
|
} else if ( str.length() < width ) {
|
|
str += std::string( width - str.length(), ' ' );
|
|
} else if ( str.length() > width ) {
|
|
str = str.substr( 0, width );
|
|
}
|
|
}
|
|
|
|
struct ColorRGBA
|
|
{
|
|
uint8_t r, g, b, a;
|
|
};
|
|
|
|
union Color
|
|
{
|
|
ColorRGBA rgba;
|
|
COLORREF dw;
|
|
};
|
|
|
|
static_assert(sizeof(Color) == 4);
|
|
|
|
HDC visDC;
|
|
HGDIOBJ visbitmap;
|
|
|
|
Color viscolors[col_max];
|
|
HPEN vispens[col_max];
|
|
HBRUSH visbrushs[col_max];
|
|
HFONT visfont;
|
|
static int last_pattern = -1;
|
|
|
|
static Color invert_color( Color c ) {
|
|
Color res;
|
|
res.rgba.a = c.rgba.a;
|
|
res.rgba.r = 255 - c.rgba.r;
|
|
res.rgba.g = 255 - c.rgba.g;
|
|
res.rgba.b = 255 - c.rgba.b;
|
|
return res;
|
|
}
|
|
|
|
static BOOL WINAPI VisOpen(DWORD colors[3]) {
|
|
xmpopenmpt_lock guard;
|
|
visDC = 0;
|
|
visbitmap = 0;
|
|
visfont = 0;
|
|
|
|
viscolors[col_background].dw = colors[0];
|
|
viscolors[col_unknown].dw = colors[1];
|
|
viscolors[col_text].dw = colors[2];
|
|
|
|
viscolors[col_global] = invert_color( viscolors[col_background] );
|
|
|
|
const int r = viscolors[col_text].rgba.r, g = viscolors[col_text].rgba.g, b = viscolors[col_text].rgba.b;
|
|
viscolors[col_empty].rgba.r = static_cast<std::uint8_t>( (r + viscolors[col_background].rgba.r) / 2 );
|
|
viscolors[col_empty].rgba.g = static_cast<std::uint8_t>( (g + viscolors[col_background].rgba.g) / 2 );
|
|
viscolors[col_empty].rgba.b = static_cast<std::uint8_t>( (b + viscolors[col_background].rgba.b) / 2 );
|
|
viscolors[col_empty].rgba.a = 0;
|
|
|
|
#define MIXCOLOR(col, c1, c2, c3) { \
|
|
viscolors[col] = viscolors[col_text]; \
|
|
int mix = viscolors[col].rgba.c1 + 0xA0; \
|
|
viscolors[col].rgba.c1 = static_cast<std::uint8_t>( mix ); \
|
|
if ( mix > 0xFF ) { \
|
|
viscolors[col].rgba.c2 = std::max( static_cast<std::uint8_t>( c2 - viscolors[col].rgba.c1 / 2 ), std::uint8_t(0) ); \
|
|
viscolors[col].rgba.c3 = std::max( static_cast<std::uint8_t>( c3 - viscolors[col].rgba.c1 / 2 ), std::uint8_t(0) ); \
|
|
viscolors[col].rgba.c1 = 0xFF; \
|
|
} }
|
|
|
|
MIXCOLOR(col_instr, g, r, b);
|
|
MIXCOLOR(col_vol, b, r, g);
|
|
MIXCOLOR(col_pitch, r, g, b);
|
|
#undef MIXCOLOR
|
|
|
|
for( int i = 0; i < col_max; ++i ) {
|
|
vispens[i] = CreatePen( PS_SOLID, 1, viscolors[i].dw );
|
|
visbrushs[i] = CreateSolidBrush( viscolors[i].dw );
|
|
}
|
|
|
|
clear_current_timeinfo();
|
|
|
|
if ( !self->mod ) {
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
static void WINAPI VisClose() {
|
|
xmpopenmpt_lock guard;
|
|
|
|
for( int i = 0; i < col_max; ++i ) {
|
|
DeletePen( vispens[i] );
|
|
DeleteBrush( visbrushs[i] );
|
|
}
|
|
|
|
DeleteFont( visfont );
|
|
DeleteBitmap( visbitmap );
|
|
if ( visDC ) {
|
|
DeleteDC( visDC );
|
|
}
|
|
}
|
|
static void WINAPI VisSize( HDC /* dc */ , SIZE * /* size */ ) {
|
|
xmpopenmpt_lock guard;
|
|
last_pattern = -1; // Force redraw
|
|
}
|
|
|
|
#if 0
|
|
static BOOL WINAPI VisRender( DWORD * /* buf */ , SIZE /* size */ , DWORD /* flags */ ) {
|
|
xmpopenmpt_lock guard;
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
static int get_pattern_width( int chars_per_channel, int spaces_per_channel, int num_cols, int text_size, int channels )
|
|
{
|
|
int pattern_width = ((chars_per_channel * channels + 4) * text_size) + (spaces_per_channel * channels + channels - (num_cols == 1 ? 1 : 2)) * (text_size / 2);
|
|
return pattern_width;
|
|
}
|
|
|
|
static BOOL WINAPI VisRenderDC( HDC dc, SIZE size, DWORD flags ) {
|
|
xmpopenmpt_lock guard;
|
|
RECT rect;
|
|
|
|
if ( !visfont ) {
|
|
// Force usage of a nice monospace font
|
|
LOGFONT logfont;
|
|
GetObject ( GetCurrentObject( dc, OBJ_FONT ), sizeof(logfont), &logfont );
|
|
_tcscpy( logfont.lfFaceName, TEXT("Lucida Console") );
|
|
visfont = CreateFontIndirect( &logfont );
|
|
}
|
|
SIZE text_size;
|
|
SelectFont( dc, visfont );
|
|
if ( GetTextExtentPoint32( dc, TEXT("W"), 1, &text_size ) == FALSE ) {
|
|
return FALSE;
|
|
}
|
|
|
|
if ( flags & XMPIN_VIS_INIT ) {
|
|
last_pattern = -1;
|
|
}
|
|
|
|
timeinfo info = lookup_timeinfo( xmpfstatus->GetTime() );
|
|
|
|
if ( !info.valid ) {
|
|
RECT bgrect;
|
|
bgrect.top = 0;
|
|
bgrect.left = 0;
|
|
bgrect.right = size.cx;
|
|
bgrect.bottom = size.cy;
|
|
FillRect(dc, &bgrect, visbrushs[col_background]);
|
|
return TRUE;
|
|
}
|
|
|
|
int pattern = info.pattern;
|
|
int current_row = info.row;
|
|
|
|
const std::size_t channels = self->mod->get_num_channels();
|
|
const std::size_t rows = self->mod->get_pattern_num_rows( pattern );
|
|
|
|
const std::size_t num_half_chars = std::max( static_cast<std::size_t>( 2 * size.cx / text_size.cx ), std::size_t(8) ) - 8;
|
|
//const std::size_t num_rows = size.cy / text_size.cy;
|
|
|
|
// Spaces between pattern components are half width, full space at channel end
|
|
const std::size_t half_chars_per_channel = num_half_chars / channels;
|
|
std::size_t chars_per_channel, spaces_per_channel;
|
|
std::size_t num_cols;
|
|
std::size_t col0_width = pattern_columns[0].num_chars;
|
|
for ( num_cols = sizeof ( pattern_columns ) / sizeof ( pattern_columns[0] ); num_cols >= 1; num_cols-- ) {
|
|
chars_per_channel = 0;
|
|
spaces_per_channel = num_cols > 1 ? num_cols : 0; // No extra space if we only display notes
|
|
for ( std::size_t i = 0; i < num_cols; i++ ) {
|
|
chars_per_channel += pattern_columns[i].num_chars;
|
|
}
|
|
|
|
if ( half_chars_per_channel >= chars_per_channel * 2 + spaces_per_channel + 1 || num_cols == 1 ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !self->settings.vis_allow_scroll ) {
|
|
if ( num_cols == 1 ) {
|
|
spaces_per_channel = 0;
|
|
while ( get_pattern_width( chars_per_channel, spaces_per_channel, num_cols, text_size.cx, channels ) > size.cx && chars_per_channel > 1 ) {
|
|
chars_per_channel -= 1;
|
|
}
|
|
col0_width = chars_per_channel;
|
|
chars_per_channel = col0_width;
|
|
}
|
|
}
|
|
|
|
int pattern_width = get_pattern_width( chars_per_channel, spaces_per_channel, num_cols, text_size.cx, channels );
|
|
int pattern_height = rows * text_size.cy;
|
|
|
|
if ( !visDC || last_pattern != pattern ) {
|
|
DeleteBitmap( visbitmap );
|
|
if ( visDC ) {
|
|
DeleteDC( visDC );
|
|
}
|
|
|
|
visDC = CreateCompatibleDC( dc );
|
|
visbitmap = CreateCompatibleBitmap( dc, pattern_width, pattern_height );
|
|
SelectBitmap( visDC, visbitmap );
|
|
|
|
SelectBrush( visDC, vispens[col_unknown] );
|
|
SelectBrush( visDC, visbrushs[col_background] );
|
|
|
|
SelectFont( visDC, visfont );
|
|
|
|
rect.top = 0;
|
|
rect.left = 0;
|
|
rect.right = pattern_width;
|
|
rect.bottom = pattern_height;
|
|
FillRect( visDC, &rect, visbrushs[col_background] );
|
|
|
|
SetBkColor( visDC, viscolors[col_background].dw );
|
|
|
|
POINT pos;
|
|
pos.y = 0;
|
|
|
|
for ( std::size_t row = 0; row < rows; row++ ) {
|
|
pos.x = 0;
|
|
|
|
std::ostringstream s;
|
|
s.imbue(std::locale::classic());
|
|
s << std::setfill('0') << std::setw(3) << row;
|
|
const std::string rowstr = s.str();
|
|
|
|
SetTextColor( visDC, viscolors[1].dw );
|
|
TextOutA( visDC, pos.x, pos.y, rowstr.c_str(), rowstr.length() );
|
|
pos.x += 4 * text_size.cx;
|
|
|
|
for ( std::size_t channel = 0; channel < channels; ++channel ) {
|
|
|
|
struct coldata {
|
|
std::string text;
|
|
bool is_empty;
|
|
ColorIndex color;
|
|
coldata()
|
|
: is_empty(false)
|
|
, color(col_unknown)
|
|
{
|
|
return;
|
|
}
|
|
};
|
|
|
|
coldata cols[max_cols];
|
|
|
|
for ( std::size_t col = 0; col < max_cols; ++col ) {
|
|
switch ( col ) {
|
|
case 0:
|
|
cols[col].text = self->mod->format_pattern_row_channel_command( pattern, row, channel, openmpt::module::command_note );
|
|
break;
|
|
case 1:
|
|
cols[col].text = self->mod->format_pattern_row_channel_command( pattern, row, channel, openmpt::module::command_instrument );
|
|
break;
|
|
case 2:
|
|
cols[col].text = self->mod->format_pattern_row_channel_command( pattern, row, channel, openmpt::module::command_volumeffect )
|
|
+ self->mod->format_pattern_row_channel_command( pattern, row, channel, openmpt::module::command_volume );
|
|
break;
|
|
case 3:
|
|
cols[col].text = self->mod->format_pattern_row_channel_command( pattern, row, channel, openmpt::module::command_effect )
|
|
+ self->mod->format_pattern_row_channel_command( pattern, row, channel, openmpt::module::command_parameter );
|
|
break;
|
|
}
|
|
int color = pattern_columns[col].color;
|
|
if ( self->pattern_vis && ( col == 2 || col == 3 ) ) {
|
|
if ( col == 2 ) {
|
|
color = effect_type_to_color_index( self->pattern_vis->get_pattern_row_channel_volume_effect_type( pattern, row, channel ) );
|
|
}
|
|
if ( col == 3 ) {
|
|
color = effect_type_to_color_index( self->pattern_vis->get_pattern_row_channel_effect_type( pattern, row, channel ) );
|
|
}
|
|
}
|
|
switch ( cols[col].text[0] ) {
|
|
case ' ':
|
|
[[fallthrough]];
|
|
case '.':
|
|
cols[col].is_empty = true;
|
|
[[fallthrough]];
|
|
case '^':
|
|
[[fallthrough]];
|
|
case '=':
|
|
[[fallthrough]];
|
|
case '~':
|
|
color = col_empty;
|
|
break;
|
|
}
|
|
cols[col].color = (ColorIndex)color;
|
|
|
|
}
|
|
|
|
if ( num_cols <= 3 && !cols[3].is_empty ) {
|
|
if ( cols[2].is_empty ) {
|
|
cols[2] = cols[3];
|
|
} else if ( cols[0].is_empty ) {
|
|
cols[0] = cols[3];
|
|
}
|
|
}
|
|
|
|
if ( num_cols <= 2 && !cols[2].is_empty ) {
|
|
if ( cols[0].is_empty ) {
|
|
cols[0] = cols[2];
|
|
}
|
|
}
|
|
|
|
for ( std::size_t col = 0; col < num_cols; ++col ) {
|
|
|
|
std::size_t col_width = ( num_cols > 1 ) ? pattern_columns[col].num_chars : col0_width;
|
|
|
|
assure_width( cols[col].text, col_width );
|
|
|
|
SetTextColor( visDC, viscolors[cols[col].color].dw );
|
|
TextOutA( visDC, pos.x, pos.y, cols[col].text.c_str(), cols[col].text.length() );
|
|
pos.x += col_width * text_size.cx + text_size.cx / 2;
|
|
}
|
|
// Extra padding
|
|
if ( num_cols > 1 ) {
|
|
pos.x += text_size.cx / 2;
|
|
}
|
|
}
|
|
|
|
pos.y += text_size.cy;
|
|
}
|
|
}
|
|
|
|
rect.top = 0;
|
|
rect.left = 0;
|
|
rect.right = size.cx;
|
|
rect.bottom = size.cy;
|
|
FillRect( dc, &rect, visbrushs[col_background] );
|
|
|
|
int offset_x = (size.cx - pattern_width) / 2;
|
|
int offset_y = (size.cy - text_size.cy) / 2 - current_row * text_size.cy;
|
|
int src_offset_x = 0;
|
|
int src_offset_y = 0;
|
|
|
|
if ( offset_x < 0 ) {
|
|
src_offset_x -= offset_x;
|
|
pattern_width = std::min( static_cast<int>( pattern_width + offset_x ), static_cast<int>( size.cx ) );
|
|
offset_x = 0;
|
|
}
|
|
|
|
if ( offset_y < 0 ) {
|
|
src_offset_y -= offset_y;
|
|
pattern_height = std::min( static_cast<int>( pattern_height + offset_y ), static_cast<int>( size.cy ) );
|
|
offset_y = 0;
|
|
}
|
|
|
|
BitBlt( dc, offset_x, offset_y, pattern_width, pattern_height, visDC, src_offset_x, src_offset_y , SRCCOPY );
|
|
|
|
// Highlight current row
|
|
rect.left = offset_x;
|
|
rect.top = (size.cy - text_size.cy) / 2;
|
|
rect.right = rect.left + pattern_width;
|
|
rect.bottom = rect.top + text_size.cy;
|
|
InvertRect( dc, &rect );
|
|
|
|
last_pattern = pattern;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#if 0
|
|
static void WINAPI VisButton( DWORD /* x */ , DWORD /* y */ ) {
|
|
//xmpopenmpt_lock guard;
|
|
}
|
|
#endif
|
|
|
|
static XMPIN xmpin = {
|
|
#ifdef USE_XMPLAY_FILE_IO
|
|
0 |
|
|
#else
|
|
XMPIN_FLAG_NOXMPFILE |
|
|
#endif
|
|
XMPIN_FLAG_CONFIG | XMPIN_FLAG_LOOP,
|
|
xmp_openmpt_string,
|
|
nullptr, // "libopenmpt\0mptm/mptmz",
|
|
openmpt_About,
|
|
openmpt_Config,
|
|
openmpt_CheckFile,
|
|
openmpt_GetFileInfo,
|
|
openmpt_Open,
|
|
openmpt_Close,
|
|
nullptr, // reserved
|
|
openmpt_SetFormat,
|
|
openmpt_GetTags,
|
|
openmpt_GetInfoText,
|
|
openmpt_GetGeneralInfo,
|
|
openmpt_GetMessage,
|
|
openmpt_SetPosition,
|
|
openmpt_GetGranularity,
|
|
nullptr, // GetBuffering
|
|
openmpt_Process,
|
|
nullptr, // WriteFile
|
|
openmpt_GetSamples,
|
|
openmpt_GetSubSongs, // GetSubSongs
|
|
nullptr, // GetCues
|
|
nullptr, // GetDownloaded
|
|
|
|
"OpenMPT Pattern Display",
|
|
VisOpen,
|
|
VisClose,
|
|
VisSize,
|
|
/*VisRender,*/nullptr,
|
|
VisRenderDC,
|
|
/*VisButton,*/nullptr,
|
|
|
|
nullptr, // reserved2
|
|
openmpt_GetConfig,
|
|
openmpt_SetConfig
|
|
};
|
|
|
|
static const char * xmp_openmpt_default_exts = "OpenMPT\0mptm/mptmz";
|
|
|
|
static char * file_formats;
|
|
|
|
static void xmp_openmpt_on_dll_load() {
|
|
ZeroMemory( &xmpopenmpt_mutex, sizeof( xmpopenmpt_mutex ) );
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(push)
|
|
#pragma warning(disable:28125) // The function 'InitializeCriticalSection' must be called from within a try/except block: The requirement might be conditional.
|
|
#endif // _MSC_VER
|
|
InitializeCriticalSection( &xmpopenmpt_mutex );
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(pop)
|
|
#endif // _MSC_VER
|
|
std::vector<std::string> extensions = openmpt::get_supported_extensions();
|
|
std::string filetypes_string = "OpenMPT";
|
|
filetypes_string.push_back('\0');
|
|
bool first = true;
|
|
for ( const auto & ext : extensions ) {
|
|
if ( first ) {
|
|
first = false;
|
|
} else {
|
|
filetypes_string.push_back('/');
|
|
}
|
|
filetypes_string += ext;
|
|
}
|
|
filetypes_string.push_back('\0');
|
|
file_formats = (char*)HeapAlloc( GetProcessHeap(), 0, filetypes_string.size() );
|
|
if ( file_formats ) {
|
|
std::copy( filetypes_string.begin(), filetypes_string.end(), file_formats );
|
|
xmpin.exts = file_formats;
|
|
} else {
|
|
xmpin.exts = xmp_openmpt_default_exts;
|
|
}
|
|
self = new self_xmplay_t();
|
|
}
|
|
|
|
static void xmp_openmpt_on_dll_unload() {
|
|
delete self;
|
|
self = nullptr;
|
|
if ( xmpin.exts != xmp_openmpt_default_exts ) {
|
|
HeapFree(GetProcessHeap(), 0, (LPVOID)const_cast<char*>(xmpin.exts));
|
|
}
|
|
xmpin.exts = nullptr;
|
|
DeleteCriticalSection( &xmpopenmpt_mutex );
|
|
}
|
|
|
|
static XMPIN * XMPIN_GetInterface_cxx( DWORD face, InterfaceProc faceproc ) {
|
|
if ( face != XMPIN_FACE ) return nullptr;
|
|
xmpfin=(XMPFUNC_IN*)faceproc(XMPFUNC_IN_FACE);
|
|
xmpfmisc=(XMPFUNC_MISC*)faceproc(XMPFUNC_MISC_FACE);
|
|
xmpfregistry=(XMPFUNC_REGISTRY*)faceproc(XMPFUNC_REGISTRY_FACE);
|
|
xmpffile=(XMPFUNC_FILE*)faceproc(XMPFUNC_FILE_FACE);
|
|
xmpftext=(XMPFUNC_TEXT*)faceproc(XMPFUNC_TEXT_FACE);
|
|
xmpfstatus=(XMPFUNC_STATUS*)faceproc(XMPFUNC_STATUS_FACE);
|
|
|
|
// Register keyboard shortcuts
|
|
static constexpr std::pair<DWORD, const char *> shortcuts[] = {
|
|
{ openmpt_shortcut_ex | openmpt_shortcut_tempo_decrease, "OpenMPT - Decrease Tempo" },
|
|
{ openmpt_shortcut_ex | openmpt_shortcut_tempo_increase, "OpenMPT - Increase Tempo" },
|
|
{ openmpt_shortcut_ex | openmpt_shortcut_pitch_decrease, "OpenMPT - Decrease Pitch" },
|
|
{ openmpt_shortcut_ex | openmpt_shortcut_pitch_increase, "OpenMPT - Increase Pitch" },
|
|
{ openmpt_shortcut_ex | openmpt_shortcut_switch_interpolation, "OpenMPT - Switch Interpolation" },
|
|
};
|
|
XMPSHORTCUT cut;
|
|
cut.procex = &ShortcutHandler;
|
|
for ( const auto & shortcut : shortcuts ) {
|
|
cut.id = shortcut.first;
|
|
cut.text = shortcut.second;
|
|
xmpfmisc->RegisterShortcut( &cut );
|
|
}
|
|
|
|
self->settings.load();
|
|
|
|
return &xmpin;
|
|
}
|
|
|
|
extern "C" {
|
|
|
|
// XMPLAY expects a WINAPI (which is __stdcall) function using an undecorated symbol name.
|
|
#if defined(__GNUC__)
|
|
XMPIN * WINAPI XMPIN_GetInterface_( DWORD face, InterfaceProc faceproc );
|
|
XMPIN * WINAPI XMPIN_GetInterface_( DWORD face, InterfaceProc faceproc ) {
|
|
return XMPIN_GetInterface_cxx( face, faceproc );
|
|
}
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wattribute-alias"
|
|
// clang-format off
|
|
__declspec(dllexport) void XMPIN_GetInterface() __attribute__((alias("XMPIN_GetInterface_@8")));
|
|
// clang-format on
|
|
#pragma GCC diagnostic pop
|
|
#else
|
|
XMPIN * WINAPI XMPIN_GetInterface( DWORD face, InterfaceProc faceproc ) {
|
|
return XMPIN_GetInterface_cxx( face, faceproc );
|
|
}
|
|
#pragma comment(linker, "/EXPORT:XMPIN_GetInterface=_XMPIN_GetInterface@8")
|
|
#endif
|
|
|
|
} // extern "C"
|
|
|
|
|
|
#if defined(MPT_WITH_MFC) && defined(_MFC_VER)
|
|
|
|
namespace libopenmpt {
|
|
namespace plugin {
|
|
|
|
void DllMainAttach() {
|
|
xmp_openmpt_on_dll_load();
|
|
}
|
|
|
|
void DllMainDetach() {
|
|
xmp_openmpt_on_dll_unload();
|
|
}
|
|
|
|
} // namespace plugin
|
|
} // namespace libopenmpt
|
|
|
|
#else
|
|
|
|
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved );
|
|
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved ) {
|
|
static_cast<void>(hinstDLL);
|
|
static_cast<void>(lpvReserved);
|
|
switch ( fdwReason ) {
|
|
case DLL_PROCESS_ATTACH:
|
|
xmp_openmpt_on_dll_load();
|
|
break;
|
|
case DLL_PROCESS_DETACH:
|
|
xmp_openmpt_on_dll_unload();
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#endif // NO_XMPLAY
|