steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/libopenmpt/xmp-openmpt.cpp

1894 lines
56 KiB
C++
Raw Blame History

/*
* 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
Reference in New Issue View Git Blame Copy Permalink