2552 lines
82 KiB
C++
2552 lines
82 KiB
C++
/*
|
|
* openmpt123.cpp
|
|
* --------------
|
|
* Purpose: libopenmpt command line player
|
|
* Notes : (currently none)
|
|
* Authors: OpenMPT Devs
|
|
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
|
*/
|
|
|
|
static const char * const license =
|
|
"Copyright (c) 2004-2023, OpenMPT Project Developers and Contributors" "\n"
|
|
"Copyright (c) 1997-2003, Olivier Lapicque" "\n"
|
|
"All rights reserved." "\n"
|
|
"" "\n"
|
|
"Redistribution and use in source and binary forms, with or without" "\n"
|
|
"modification, are permitted provided that the following conditions are met:" "\n"
|
|
" * Redistributions of source code must retain the above copyright" "\n"
|
|
" notice, this list of conditions and the following disclaimer." "\n"
|
|
" * Redistributions in binary form must reproduce the above copyright" "\n"
|
|
" notice, this list of conditions and the following disclaimer in the" "\n"
|
|
" documentation and/or other materials provided with the distribution." "\n"
|
|
" * Neither the name of the OpenMPT project nor the" "\n"
|
|
" names of its contributors may be used to endorse or promote products" "\n"
|
|
" derived from this software without specific prior written permission." "\n"
|
|
"" "\n"
|
|
"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"" "\n"
|
|
"AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE" "\n"
|
|
"IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE" "\n"
|
|
"DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE" "\n"
|
|
"FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL" "\n"
|
|
"DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR" "\n"
|
|
"SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER" "\n"
|
|
"CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY," "\n"
|
|
"OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE" "\n"
|
|
"OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." "\n"
|
|
;
|
|
|
|
#include "openmpt123_config.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <deque>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <limits>
|
|
#include <locale>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <random>
|
|
#include <set>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <ctime>
|
|
|
|
#if defined(__DJGPP__)
|
|
#include <conio.h>
|
|
#include <dpmi.h>
|
|
#include <fcntl.h>
|
|
#include <io.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
#elif defined(WIN32)
|
|
#include <conio.h>
|
|
#include <fcntl.h>
|
|
#include <io.h>
|
|
#include <stdio.h>
|
|
#if defined(__MINGW32__) && !defined(__MINGW64__)
|
|
#include <string.h>
|
|
#endif
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <windows.h>
|
|
#include <mmsystem.h>
|
|
#include <mmreg.h>
|
|
#else
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/poll.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
#include <libopenmpt/libopenmpt.hpp>
|
|
|
|
#include "openmpt123.hpp"
|
|
|
|
#include "openmpt123_flac.hpp"
|
|
#include "openmpt123_mmio.hpp"
|
|
#include "openmpt123_sndfile.hpp"
|
|
#include "openmpt123_raw.hpp"
|
|
#include "openmpt123_stdout.hpp"
|
|
#include "openmpt123_allegro42.hpp"
|
|
#include "openmpt123_portaudio.hpp"
|
|
#include "openmpt123_pulseaudio.hpp"
|
|
#include "openmpt123_sdl2.hpp"
|
|
#include "openmpt123_waveout.hpp"
|
|
|
|
namespace openmpt123 {
|
|
|
|
struct silent_exit_exception : public std::exception {
|
|
};
|
|
|
|
struct show_license_exception : public std::exception {
|
|
};
|
|
|
|
struct show_credits_exception : public std::exception {
|
|
};
|
|
|
|
struct show_man_version_exception : public std::exception {
|
|
};
|
|
|
|
struct show_man_help_exception : public std::exception {
|
|
};
|
|
|
|
struct show_short_version_number_exception : public std::exception {
|
|
};
|
|
|
|
struct show_version_number_exception : public std::exception {
|
|
};
|
|
|
|
struct show_long_version_number_exception : public std::exception {
|
|
};
|
|
|
|
#if defined( WIN32 )
|
|
bool IsConsole( DWORD stdHandle ) {
|
|
HANDLE hStd = GetStdHandle( stdHandle );
|
|
if ( ( hStd != NULL ) && ( hStd != INVALID_HANDLE_VALUE ) ) {
|
|
DWORD mode = 0;
|
|
if ( GetConsoleMode( hStd, &mode ) != FALSE ) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
bool IsTerminal( int fd ) {
|
|
#if defined( WIN32 )
|
|
if ( !_isatty( fd ) ) {
|
|
return false;
|
|
}
|
|
DWORD stdHandle = 0;
|
|
if ( fd == 0 ) {
|
|
stdHandle = STD_INPUT_HANDLE;
|
|
} else if ( fd == 1 ) {
|
|
stdHandle = STD_OUTPUT_HANDLE;
|
|
} else if ( fd == 2 ) {
|
|
stdHandle = STD_ERROR_HANDLE;
|
|
}
|
|
return IsConsole( stdHandle );
|
|
#else
|
|
return isatty( fd ) ? true : false;
|
|
#endif
|
|
}
|
|
|
|
#if !defined( WIN32 )
|
|
|
|
static termios saved_attributes;
|
|
|
|
static void reset_input_mode() {
|
|
tcsetattr( STDIN_FILENO, TCSANOW, &saved_attributes );
|
|
}
|
|
|
|
static void set_input_mode() {
|
|
termios tattr;
|
|
if ( !isatty( STDIN_FILENO ) ) {
|
|
return;
|
|
}
|
|
tcgetattr( STDIN_FILENO, &saved_attributes );
|
|
atexit( reset_input_mode );
|
|
tcgetattr( STDIN_FILENO, &tattr );
|
|
tattr.c_lflag &= ~( ICANON | ECHO );
|
|
tattr.c_cc[VMIN] = 1;
|
|
tattr.c_cc[VTIME] = 0;
|
|
tcsetattr( STDIN_FILENO, TCSAFLUSH, &tattr );
|
|
}
|
|
|
|
#endif
|
|
|
|
class file_audio_stream_raii : public file_audio_stream_base {
|
|
private:
|
|
std::unique_ptr<file_audio_stream_base> impl;
|
|
public:
|
|
file_audio_stream_raii( const commandlineflags & flags, const std::string & filename, std::ostream & log )
|
|
: impl(nullptr)
|
|
{
|
|
if ( !flags.force_overwrite ) {
|
|
std::ifstream testfile( filename, std::ios::binary );
|
|
if ( testfile ) {
|
|
throw exception( "file already exists" );
|
|
}
|
|
}
|
|
if ( false ) {
|
|
// nothing
|
|
} else if ( flags.output_extension == "raw" ) {
|
|
impl = std::make_unique<raw_stream_raii>( filename, flags, log );
|
|
#ifdef MPT_WITH_MMIO
|
|
} else if ( flags.output_extension == "wav" ) {
|
|
impl = std::make_unique<mmio_stream_raii>( filename, flags, log );
|
|
#endif
|
|
#ifdef MPT_WITH_FLAC
|
|
} else if ( flags.output_extension == "flac" ) {
|
|
impl = std::make_unique<flac_stream_raii>( filename, flags, log );
|
|
#endif
|
|
#ifdef MPT_WITH_SNDFILE
|
|
} else {
|
|
impl = std::make_unique<sndfile_stream_raii>( filename, flags, log );
|
|
#endif
|
|
}
|
|
if ( !impl ) {
|
|
throw exception( "file format handler '" + flags.output_extension + "' not found" );
|
|
}
|
|
}
|
|
virtual ~file_audio_stream_raii() {
|
|
return;
|
|
}
|
|
void write_metadata( std::map<std::string,std::string> metadata ) override {
|
|
impl->write_metadata( metadata );
|
|
}
|
|
void write_updated_metadata( std::map<std::string,std::string> metadata ) override {
|
|
impl->write_updated_metadata( metadata );
|
|
}
|
|
void write( const std::vector<float*> buffers, std::size_t frames ) override {
|
|
impl->write( buffers, frames );
|
|
}
|
|
void write( const std::vector<std::int16_t*> buffers, std::size_t frames ) override {
|
|
impl->write( buffers, frames );
|
|
}
|
|
};
|
|
|
|
static std::string ctls_to_string( const std::map<std::string, std::string> & ctls ) {
|
|
std::string result;
|
|
for ( const auto & ctl : ctls ) {
|
|
if ( !result.empty() ) {
|
|
result += "; ";
|
|
}
|
|
result += ctl.first + "=" + ctl.second;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static double tempo_flag_to_double( std::int32_t tempo ) {
|
|
return std::pow( 2.0, tempo / 24.0 );
|
|
}
|
|
|
|
static double pitch_flag_to_double( std::int32_t pitch ) {
|
|
return std::pow( 2.0, pitch / 24.0 );
|
|
}
|
|
|
|
static double my_round( double val ) {
|
|
if ( val >= 0.0 ) {
|
|
return std::floor( val + 0.5 );
|
|
} else {
|
|
return std::ceil( val - 0.5 );
|
|
}
|
|
}
|
|
|
|
static std::int32_t double_to_tempo_flag( double factor ) {
|
|
return static_cast<std::int32_t>( my_round( std::log( factor ) / std::log( 2.0 ) * 24.0 ) );
|
|
}
|
|
|
|
static std::int32_t double_to_pitch_flag( double factor ) {
|
|
return static_cast<std::int32_t>( my_round( std::log( factor ) / std::log( 2.0 ) * 24.0 ) );
|
|
}
|
|
|
|
static std::ostream & operator << ( std::ostream & s, const commandlineflags & flags ) {
|
|
s << "Quiet: " << flags.quiet << std::endl;
|
|
s << "Verbose: " << flags.verbose << std::endl;
|
|
s << "Mode : " << mode_to_string( flags.mode ) << std::endl;
|
|
s << "Show progress: " << flags.show_progress << std::endl;
|
|
s << "Show peak meters: " << flags.show_meters << std::endl;
|
|
s << "Show channel peak meters: " << flags.show_channel_meters << std::endl;
|
|
s << "Show details: " << flags.show_details << std::endl;
|
|
s << "Show message: " << flags.show_message << std::endl;
|
|
s << "Update: " << flags.ui_redraw_interval << "ms" << std::endl;
|
|
s << "Device: " << flags.device << std::endl;
|
|
s << "Buffer: " << flags.buffer << "ms" << std::endl;
|
|
s << "Period: " << flags.period << "ms" << std::endl;
|
|
s << "Samplerate: " << flags.samplerate << std::endl;
|
|
s << "Channels: " << flags.channels << std::endl;
|
|
s << "Float: " << flags.use_float << std::endl;
|
|
s << "Gain: " << flags.gain / 100.0 << std::endl;
|
|
s << "Stereo separation: " << flags.separation << std::endl;
|
|
s << "Interpolation filter taps: " << flags.filtertaps << std::endl;
|
|
s << "Volume ramping strength: " << flags.ramping << std::endl;
|
|
s << "Tempo: " << tempo_flag_to_double( flags.tempo ) << std::endl;
|
|
s << "Pitch: " << pitch_flag_to_double( flags.pitch ) << std::endl;
|
|
s << "Output dithering: " << flags.dither << std::endl;
|
|
s << "Repeat count: " << flags.repeatcount << std::endl;
|
|
s << "Seek target: " << flags.seek_target << std::endl;
|
|
s << "End time: " << flags.end_time << std::endl;
|
|
s << "Standard output: " << flags.use_stdout << std::endl;
|
|
s << "Output filename: " << flags.output_filename << std::endl;
|
|
s << "Force overwrite output file: " << flags.force_overwrite << std::endl;
|
|
s << "Ctls: " << ctls_to_string( flags.ctls ) << std::endl;
|
|
s << std::endl;
|
|
s << "Files: " << std::endl;
|
|
for ( const auto & filename : flags.filenames ) {
|
|
s << " " << filename << std::endl;
|
|
}
|
|
s << std::endl;
|
|
return s;
|
|
}
|
|
|
|
static std::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 bool begins_with( const std::string & str, const std::string & match ) {
|
|
return ( str.find( match ) == 0 );
|
|
}
|
|
|
|
static bool ends_with( const std::string & str, const std::string & match ) {
|
|
return ( str.rfind( match ) == ( str.length() - match.length() ) );
|
|
}
|
|
|
|
static std::string trim_left(std::string str, const std::string &whitespace = std::string()) {
|
|
std::string::size_type pos = str.find_first_not_of(whitespace);
|
|
if(pos != std::string::npos) {
|
|
str.erase(str.begin(), str.begin() + pos);
|
|
} else if(pos == std::string::npos && str.length() > 0 && str.find_last_of(whitespace) == str.length() - 1) {
|
|
return std::string();
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static std::string trim_right(std::string str, const std::string &whitespace = std::string()) {
|
|
std::string::size_type pos = str.find_last_not_of(whitespace);
|
|
if(pos != std::string::npos) {
|
|
str.erase(str.begin() + pos + 1, str.end());
|
|
} else if(pos == std::string::npos && str.length() > 0 && str.find_first_of(whitespace) == 0) {
|
|
return std::string();
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static std::string trim(std::string str, const std::string &whitespace = std::string()) {
|
|
return trim_right(trim_left(str, whitespace), whitespace);
|
|
}
|
|
|
|
static std::string trim_eol( const std::string & str ) {
|
|
return trim( str, "\r\n" );
|
|
}
|
|
|
|
static std::string default_path_separator() {
|
|
#if defined(WIN32)
|
|
return "\\";
|
|
#else
|
|
return "/";
|
|
#endif
|
|
}
|
|
|
|
static std::string path_separators() {
|
|
#if defined(WIN32)
|
|
return "\\/";
|
|
#else
|
|
return "/";
|
|
#endif
|
|
}
|
|
|
|
static bool is_path_separator( char c ) {
|
|
#if defined(WIN32)
|
|
return ( c == '\\' ) || ( c == '/' );
|
|
#else
|
|
return c == '/';
|
|
#endif
|
|
}
|
|
|
|
static std::string get_basepath( std::string filename ) {
|
|
std::string::size_type pos = filename.find_last_of( path_separators() );
|
|
if ( pos == std::string::npos ) {
|
|
return std::string();
|
|
}
|
|
return filename.substr( 0, pos ) + default_path_separator();
|
|
}
|
|
|
|
static bool is_absolute( std::string filename ) {
|
|
#if defined(WIN32)
|
|
if ( begins_with( filename, "\\\\?\\UNC\\" ) ) {
|
|
return true;
|
|
}
|
|
if ( begins_with( filename, "\\\\?\\" ) ) {
|
|
return true;
|
|
}
|
|
if ( begins_with( filename, "\\\\" ) ) {
|
|
return true; // UNC
|
|
}
|
|
if ( begins_with( filename, "//" ) ) {
|
|
return true; // UNC
|
|
}
|
|
return ( filename.length() ) >= 3 && ( filename[1] == ':' ) && is_path_separator( filename[2] );
|
|
#else
|
|
return ( filename.length() >= 1 ) && is_path_separator( filename[0] );
|
|
#endif
|
|
}
|
|
|
|
static std::string get_filename( const std::string & filepath ) {
|
|
if ( filepath.find_last_of( path_separators() ) == std::string::npos ) {
|
|
return filepath;
|
|
}
|
|
return filepath.substr( filepath.find_last_of( path_separators() ) + 1 );
|
|
}
|
|
|
|
static std::string prepend_lines( std::string str, const std::string & prefix ) {
|
|
if ( str.empty() ) {
|
|
return str;
|
|
}
|
|
if ( str.substr( str.length() - 1, 1 ) == std::string("\n") ) {
|
|
str = str.substr( 0, str.length() - 1 );
|
|
}
|
|
return replace( str, std::string("\n"), std::string("\n") + prefix );
|
|
}
|
|
|
|
static std::string bytes_to_string( std::uint64_t bytes ) {
|
|
static const char * const suffixes[] = { "B", "kB", "MB", "GB", "TB", "PB" };
|
|
int offset = 0;
|
|
while ( bytes > 9999 ) {
|
|
bytes /= 1000;
|
|
offset += 1;
|
|
if ( offset == 5 ) {
|
|
break;
|
|
}
|
|
}
|
|
std::ostringstream result;
|
|
result << bytes << suffixes[offset];
|
|
return result.str();
|
|
}
|
|
|
|
static std::string seconds_to_string( double time ) {
|
|
std::int64_t time_ms = static_cast<std::int64_t>( time * 1000 );
|
|
std::int64_t milliseconds = time_ms % 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;
|
|
str << ".";
|
|
str << std::setfill('0') << std::setw(3) << milliseconds;
|
|
return str.str();
|
|
}
|
|
|
|
static void show_info( std::ostream & log, bool verbose ) {
|
|
log << "openmpt123" << " v" << OPENMPT123_VERSION_STRING << ", libopenmpt " << openmpt::string::get( "library_version" ) << " (" << "OpenMPT " << openmpt::string::get( "core_version" ) << ")" << std::endl;
|
|
log << "Copyright (c) 2013-2023 OpenMPT Project Developers and Contributors <https://lib.openmpt.org/>" << std::endl;
|
|
if ( !verbose ) {
|
|
log << std::endl;
|
|
return;
|
|
}
|
|
log << " libopenmpt source..: " << openmpt::string::get( "source_url" ) << std::endl;
|
|
log << " libopenmpt date....: " << openmpt::string::get( "source_date" ) << std::endl;
|
|
log << " libopenmpt srcinfo.: ";
|
|
{
|
|
std::vector<std::string> fields;
|
|
if ( openmpt::string::get( "source_is_package" ) == "1" ) {
|
|
fields.push_back( "package" );
|
|
}
|
|
if ( openmpt::string::get( "source_is_release" ) == "1" ) {
|
|
fields.push_back( "release" );
|
|
}
|
|
if ( ( !openmpt::string::get( "source_revision" ).empty() ) && ( openmpt::string::get( "source_revision" ) != "0" ) ) {
|
|
std::string field = "rev" + openmpt::string::get( "source_revision" );
|
|
if ( openmpt::string::get( "source_has_mixed_revisions" ) == "1" ) {
|
|
field += "+mixed";
|
|
}
|
|
if ( openmpt::string::get( "source_is_modified" ) == "1" ) {
|
|
field += "+modified";
|
|
}
|
|
fields.push_back( field );
|
|
}
|
|
bool first = true;
|
|
for ( const auto & field : fields ) {
|
|
if ( first ) {
|
|
first = false;
|
|
} else {
|
|
log << ", ";
|
|
}
|
|
log << field;
|
|
}
|
|
}
|
|
log << std::endl;
|
|
log << " libopenmpt compiler: " << openmpt::string::get( "build_compiler" ) << std::endl;
|
|
log << " libopenmpt features: " << openmpt::string::get( "library_features" ) << std::endl;
|
|
#ifdef MPT_WITH_SDL2
|
|
log << " libSDL2 ";
|
|
SDL_version sdlver;
|
|
std::memset( &sdlver, 0, sizeof( SDL_version ) );
|
|
SDL_GetVersion( &sdlver );
|
|
log << static_cast<int>( sdlver.major ) << "." << static_cast<int>( sdlver.minor ) << "." << static_cast<int>( sdlver.patch );
|
|
const char * revision = SDL_GetRevision();
|
|
if ( revision ) {
|
|
log << " (" << revision << ")";
|
|
}
|
|
log << ", ";
|
|
std::memset( &sdlver, 0, sizeof( SDL_version ) );
|
|
SDL_VERSION( &sdlver );
|
|
log << "API: " << static_cast<int>( sdlver.major ) << "." << static_cast<int>( sdlver.minor ) << "." << static_cast<int>( sdlver.patch ) << "";
|
|
log << " <https://libsdl.org/>" << std::endl;
|
|
#endif
|
|
#ifdef MPT_WITH_PULSEAUDIO
|
|
log << " " << "libpulse, libpulse-simple" << " (headers " << pa_get_headers_version() << ", API " << PA_API_VERSION << ", PROTOCOL " << PA_PROTOCOL_VERSION << ", library " << ( pa_get_library_version() ? pa_get_library_version() : "unknown" ) << ") <https://www.freedesktop.org/wiki/Software/PulseAudio/>" << std::endl;
|
|
#endif
|
|
#ifdef MPT_WITH_PORTAUDIO
|
|
log << " " << Pa_GetVersionText() << " (" << Pa_GetVersion() << ") <http://portaudio.com/>" << std::endl;
|
|
#endif
|
|
#ifdef MPT_WITH_FLAC
|
|
log << " FLAC " << FLAC__VERSION_STRING << ", " << FLAC__VENDOR_STRING << ", API " << FLAC_API_VERSION_CURRENT << "." << FLAC_API_VERSION_REVISION << "." << FLAC_API_VERSION_AGE << " <https://xiph.org/flac/>" << std::endl;
|
|
#endif
|
|
#ifdef MPT_WITH_SNDFILE
|
|
char sndfile_info[128];
|
|
std::memset( sndfile_info, 0, sizeof( sndfile_info ) );
|
|
sf_command( 0, SFC_GET_LIB_VERSION, sndfile_info, sizeof( sndfile_info ) );
|
|
sndfile_info[127] = '\0';
|
|
log << " libsndfile " << sndfile_info << " <http://mega-nerd.com/libsndfile/>" << std::endl;
|
|
#endif
|
|
log << std::endl;
|
|
}
|
|
|
|
static void show_man_version( textout & log ) {
|
|
log << "openmpt123" << " v" << OPENMPT123_VERSION_STRING << std::endl;
|
|
log << std::endl;
|
|
log << "Copyright (c) 2013-2023 OpenMPT Project Developers and Contributors <https://lib.openmpt.org/>" << std::endl;
|
|
}
|
|
|
|
static void show_short_version( textout & log ) {
|
|
log << OPENMPT123_VERSION_STRING << " / " << openmpt::string::get( "library_version" ) << " / " << openmpt::string::get( "core_version" ) << std::endl;
|
|
log.writeout();
|
|
}
|
|
|
|
static void show_version( textout & log ) {
|
|
show_info( log, false );
|
|
log.writeout();
|
|
}
|
|
|
|
static void show_long_version( textout & log ) {
|
|
show_info( log, true );
|
|
log.writeout();
|
|
}
|
|
|
|
static void show_credits( textout & log ) {
|
|
show_info( log, false );
|
|
log << openmpt::string::get( "contact" ) << std::endl;
|
|
log << std::endl;
|
|
log << openmpt::string::get( "credits" ) << std::endl;
|
|
log.writeout();
|
|
}
|
|
|
|
static void show_license( textout & log ) {
|
|
show_info( log, false );
|
|
log << license << std::endl;
|
|
log.writeout();
|
|
}
|
|
|
|
static std::string get_driver_string( const std::string & driver ) {
|
|
if ( driver.empty() ) {
|
|
return "default";
|
|
}
|
|
return driver;
|
|
}
|
|
|
|
static std::string get_device_string( const std::string & device ) {
|
|
if ( device.empty() ) {
|
|
return "default";
|
|
}
|
|
return device;
|
|
}
|
|
|
|
static void show_help_keyboard( textout & log, bool man_version = false ) {
|
|
if ( !man_version ) {
|
|
show_info( log, false );
|
|
}
|
|
log << "Keyboard hotkeys (use 'openmpt123 --ui'):" << std::endl;
|
|
log << std::endl;
|
|
log << " [q] quit" << std::endl;
|
|
log << " [ ] pause / unpause" << std::endl;
|
|
log << " [N] skip 10 files backward" << std::endl;
|
|
log << " [n] prev file" << std::endl;
|
|
log << " [m] next file" << std::endl;
|
|
log << " [M] skip 10 files forward" << std::endl;
|
|
log << " [h] seek 10 seconds backward" << std::endl;
|
|
log << " [j] seek 1 seconds backward" << std::endl;
|
|
log << " [k] seek 1 seconds forward" << std::endl;
|
|
log << " [l] seek 10 seconds forward" << std::endl;
|
|
log << " [u]|[i] +/- tempo" << std::endl;
|
|
log << " [o]|[p] +/- pitch" << std::endl;
|
|
log << " [3]|[4] +/- gain" << std::endl;
|
|
log << " [5]|[6] +/- stereo separation" << std::endl;
|
|
log << " [7]|[8] +/- filter taps" << std::endl;
|
|
log << " [9]|[0] +/- volume ramping" << std::endl;
|
|
log << std::endl;
|
|
if ( !man_version ) {
|
|
log.writeout();
|
|
}
|
|
}
|
|
|
|
static void show_help( textout & log, bool with_info = true, bool longhelp = false, bool man_version = false, const std::string & message = std::string() ) {
|
|
if ( with_info ) {
|
|
show_info( log, false );
|
|
}
|
|
{
|
|
log << "Usage: openmpt123 [options] [--] file1 [file2] ..." << std::endl;
|
|
log << std::endl;
|
|
if ( man_version ) {
|
|
log << "openmpt123 plays module music files." << std::endl;
|
|
log << std::endl;
|
|
}
|
|
if ( man_version ) {
|
|
log << "Options:" << std::endl;
|
|
log << std::endl;
|
|
}
|
|
log << " -h, --help Show help" << std::endl;
|
|
log << " --help-keyboard Show keyboard hotkeys in ui mode" << std::endl;
|
|
log << " -q, --quiet Suppress non-error screen output" << std::endl;
|
|
log << " -v, --verbose Show more screen output" << std::endl;
|
|
log << " --version Show version information and exit" << std::endl;
|
|
log << " --short-version Show version number and nothing else" << std::endl;
|
|
log << " --long-version Show long version information and exit" << std::endl;
|
|
log << " --credits Show elaborate contributors list" << std::endl;
|
|
log << " --license Show license" << std::endl;
|
|
log << std::endl;
|
|
log << " --probe Probe each file whether it is a supported file format" << std::endl;
|
|
log << " --info Display information about each file" << std::endl;
|
|
log << " --ui Interactively play each file" << std::endl;
|
|
log << " --batch Play each file" << std::endl;
|
|
log << " --render Render each file to individual PCM data files" << std::endl;
|
|
if ( !longhelp ) {
|
|
log << std::endl;
|
|
log.writeout();
|
|
return;
|
|
}
|
|
log << std::endl;
|
|
log << " --terminal-width n Assume terminal is n characters wide [default: " << commandlineflags().terminal_width << "]" << std::endl;
|
|
log << " --terminal-height n Assume terminal is n characters high [default: " << commandlineflags().terminal_height << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " --[no-]progress Show playback progress [default: " << commandlineflags().show_progress << "]" << std::endl;
|
|
log << " --[no-]meters Show peak meters [default: " << commandlineflags().show_meters << "]" << std::endl;
|
|
log << " --[no-]channel-meters Show channel peak meters (EXPERIMENTAL) [default: " << commandlineflags().show_channel_meters << "]" << std::endl;
|
|
log << " --[no-]pattern Show pattern (EXPERIMENTAL) [default: " << commandlineflags().show_pattern << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " --[no-]details Show song details [default: " << commandlineflags().show_details << "]" << std::endl;
|
|
log << " --[no-]message Show song message [default: " << commandlineflags().show_message << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " --update n Set output update interval to n ms [default: " << commandlineflags().ui_redraw_interval << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " --samplerate n Set samplerate to n Hz [default: " << commandlineflags().samplerate << "]" << std::endl;
|
|
log << " --channels n use n [1,2,4] output channels [default: " << commandlineflags().channels << "]" << std::endl;
|
|
log << " --[no-]float Output 32bit floating point instead of 16bit integer [default: " << commandlineflags().use_float << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " --gain n Set output gain to n dB [default: " << commandlineflags().gain / 100.0 << "]" << std::endl;
|
|
log << " --stereo n Set stereo separation to n % [default: " << commandlineflags().separation << "]" << std::endl;
|
|
log << " --filter n Set interpolation filter taps to n [1,2,4,8] [default: " << commandlineflags().filtertaps << "]" << std::endl;
|
|
log << " --ramping n Set volume ramping strength n [0..5] [default: " << commandlineflags().ramping << "]" << std::endl;
|
|
log << " --tempo f Set tempo factor f [default: " << tempo_flag_to_double( commandlineflags().tempo ) << "]" << std::endl;
|
|
log << " --pitch f Set pitch factor f [default: " << pitch_flag_to_double( commandlineflags().pitch ) << "]" << std::endl;
|
|
log << " --dither n Dither type to use (if applicable for selected output format): [0=off,1=auto,2=0.5bit,3=1bit] [default: " << commandlineflags().dither << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " --playlist file Load playlist from file" << std::endl;
|
|
log << " --[no-]randomize Randomize playlist [default: " << commandlineflags().randomize << "]" << std::endl;
|
|
log << " --[no-]shuffle Shuffle through playlist [default: " << commandlineflags().shuffle << "]" << std::endl;
|
|
log << " --[no-]restart Restart playlist when finished [default: " << commandlineflags().restart << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " --subsong n Select subsong n (-1 means play all subsongs consecutively) [default: " << commandlineflags().subsong << "]" << std::endl;
|
|
log << " --repeat n Repeat song n times (-1 means forever) [default: " << commandlineflags().repeatcount << "]" << std::endl;
|
|
log << " --seek n Seek to n seconds on start [default: " << commandlineflags().seek_target << "]" << std::endl;
|
|
log << " --end-time n Play until position is n seconds (0 means until the end) [default: " << commandlineflags().end_time << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " --ctl c=v Set libopenmpt ctl c to value v" << std::endl;
|
|
log << std::endl;
|
|
log << " --driver n Set output driver [default: " << get_driver_string( commandlineflags().driver ) << "]," << std::endl;
|
|
log << " --device n Set output device [default: " << get_device_string( commandlineflags().device ) << "]," << std::endl;
|
|
log << " use --device help to show available devices" << std::endl;
|
|
log << " --buffer n Set output buffer size to n ms [default: " << commandlineflags().buffer << "]" << std::endl;
|
|
log << " --period n Set output period size to n ms [default: " << commandlineflags().period << "]" << std::endl;
|
|
log << " --stdout Write raw audio data to stdout [default: " << commandlineflags().use_stdout << "]" << std::endl;
|
|
log << " --output-type t Use output format t when writing to a individual PCM files (only applies to --render mode) [default: " << commandlineflags().output_extension << "]" << std::endl;
|
|
log << " -o, --output f Write PCM output to file f instead of streaming to audio device (only applies to --ui and --batch modes) [default: " << commandlineflags().output_filename << "]" << std::endl;
|
|
log << " --force Force overwriting of output file [default: " << commandlineflags().force_overwrite << "]" << std::endl;
|
|
log << std::endl;
|
|
log << " -- Interpret further arguments as filenames" << std::endl;
|
|
log << std::endl;
|
|
if ( !man_version ) {
|
|
log << " Supported file formats: " << std::endl;
|
|
log << " ";
|
|
std::vector<std::string> extensions = openmpt::get_supported_extensions();
|
|
bool first = true;
|
|
for ( const auto & extension : extensions ) {
|
|
if ( first ) {
|
|
first = false;
|
|
} else {
|
|
log << ", ";
|
|
}
|
|
log << extension;
|
|
}
|
|
log << std::endl;
|
|
} else {
|
|
show_help_keyboard( log, true );
|
|
}
|
|
}
|
|
|
|
log << std::endl;
|
|
|
|
if ( message.size() > 0 ) {
|
|
log << message;
|
|
log << std::endl;
|
|
}
|
|
log.writeout();
|
|
}
|
|
|
|
|
|
template < typename Tmod >
|
|
static void apply_mod_settings( commandlineflags & flags, Tmod & mod ) {
|
|
flags.separation = std::max( flags.separation, std::int32_t( 0 ) );
|
|
flags.filtertaps = std::max( flags.filtertaps, std::int32_t( 1 ) );
|
|
flags.filtertaps = std::min( flags.filtertaps, std::int32_t( 8 ) );
|
|
flags.ramping = std::max( flags.ramping, std::int32_t( -1 ) );
|
|
flags.ramping = std::min( flags.ramping, std::int32_t( 10 ) );
|
|
flags.tempo = std::max( flags.tempo, std::int32_t( -48 ) );
|
|
flags.tempo = std::min( flags.tempo, std::int32_t( 48 ) );
|
|
flags.pitch = std::max( flags.pitch, std::int32_t( -48 ) );
|
|
flags.pitch = std::min( flags.pitch, std::int32_t( 48 ) );
|
|
mod.set_render_param( openmpt::module::RENDER_MASTERGAIN_MILLIBEL, flags.gain );
|
|
mod.set_render_param( openmpt::module::RENDER_STEREOSEPARATION_PERCENT, flags.separation );
|
|
mod.set_render_param( openmpt::module::RENDER_INTERPOLATIONFILTER_LENGTH, flags.filtertaps );
|
|
mod.set_render_param( openmpt::module::RENDER_VOLUMERAMPING_STRENGTH, flags.ramping );
|
|
try {
|
|
mod.ctl_set_floatingpoint( "play.tempo_factor", tempo_flag_to_double( flags.tempo ) );
|
|
} catch ( const openmpt::exception & ) {
|
|
// ignore
|
|
}
|
|
try {
|
|
mod.ctl_set_floatingpoint( "play.pitch_factor", pitch_flag_to_double( flags.pitch ) );
|
|
} catch ( const openmpt::exception & ) {
|
|
// ignore
|
|
}
|
|
mod.ctl_set_integer( "dither", flags.dither );
|
|
}
|
|
|
|
struct prev_file { int count; prev_file( int c ) : count(c) { } };
|
|
struct next_file { int count; next_file( int c ) : count(c) { } };
|
|
|
|
template < typename Tmod >
|
|
static bool handle_keypress( int c, commandlineflags & flags, Tmod & mod, write_buffers_interface & audio_stream ) {
|
|
switch ( c ) {
|
|
case 'q': throw silent_exit_exception(); break;
|
|
case 'N': throw prev_file(10); break;
|
|
case 'n': throw prev_file(1); break;
|
|
case ' ': if ( !flags.paused ) { flags.paused = audio_stream.pause(); } else { flags.paused = false; audio_stream.unpause(); } break;
|
|
case 'h': mod.set_position_seconds( mod.get_position_seconds() - 10.0 ); break;
|
|
case 'j': mod.set_position_seconds( mod.get_position_seconds() - 1.0 ); break;
|
|
case 'k': mod.set_position_seconds( mod.get_position_seconds() + 1.0 ); break;
|
|
case 'l': mod.set_position_seconds( mod.get_position_seconds() + 10.0 ); break;
|
|
case 'H': mod.set_position_order_row( mod.get_current_order() - 1, 0 ); break;
|
|
case 'J': mod.set_position_order_row( mod.get_current_order(), mod.get_current_row() - 1 ); break;
|
|
case 'K': mod.set_position_order_row( mod.get_current_order(), mod.get_current_row() + 1 ); break;
|
|
case 'L': mod.set_position_order_row( mod.get_current_order() + 1, 0 ); break;
|
|
case 'm': throw next_file(1); break;
|
|
case 'M': throw next_file(10); break;
|
|
case 'u': flags.tempo -= 1; apply_mod_settings( flags, mod ); break;
|
|
case 'i': flags.tempo += 1; apply_mod_settings( flags, mod ); break;
|
|
case 'o': flags.pitch -= 1; apply_mod_settings( flags, mod ); break;
|
|
case 'p': flags.pitch += 1; apply_mod_settings( flags, mod ); break;
|
|
case '3': flags.gain -=100; apply_mod_settings( flags, mod ); break;
|
|
case '4': flags.gain +=100; apply_mod_settings( flags, mod ); break;
|
|
case '5': flags.separation -= 5; apply_mod_settings( flags, mod ); break;
|
|
case '6': flags.separation += 5; apply_mod_settings( flags, mod ); break;
|
|
case '7': flags.filtertaps /= 2; apply_mod_settings( flags, mod ); break;
|
|
case '8': flags.filtertaps *= 2; apply_mod_settings( flags, mod ); break;
|
|
case '9': flags.ramping -= 1; apply_mod_settings( flags, mod ); break;
|
|
case '0': flags.ramping += 1; apply_mod_settings( flags, mod ); break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
struct meter_channel {
|
|
float peak;
|
|
float clip;
|
|
float hold;
|
|
float hold_age;
|
|
meter_channel()
|
|
: peak(0.0f)
|
|
, clip(0.0f)
|
|
, hold(0.0f)
|
|
, hold_age(0.0f)
|
|
{
|
|
return;
|
|
}
|
|
};
|
|
|
|
struct meter_type {
|
|
meter_channel channels[4];
|
|
};
|
|
|
|
static const float falloff_rate = 20.0f / 1.7f;
|
|
|
|
static void update_meter( meter_type & meter, const commandlineflags & flags, std::size_t count, const std::int16_t * const * buffers ) {
|
|
float falloff_factor = std::pow( 10.0f, -falloff_rate / flags.samplerate / 20.0f );
|
|
for ( int channel = 0; channel < flags.channels; ++channel ) {
|
|
meter.channels[channel].peak = 0.0f;
|
|
for ( std::size_t frame = 0; frame < count; ++frame ) {
|
|
if ( meter.channels[channel].clip != 0.0f ) {
|
|
meter.channels[channel].clip -= ( 1.0f / 2.0f ) * 1.0f / static_cast<float>( flags.samplerate );
|
|
if ( meter.channels[channel].clip <= 0.0f ) {
|
|
meter.channels[channel].clip = 0.0f;
|
|
}
|
|
}
|
|
float val = std::fabs( buffers[channel][frame] / 32768.0f );
|
|
if ( val >= 1.0f ) {
|
|
meter.channels[channel].clip = 1.0f;
|
|
}
|
|
if ( val > meter.channels[channel].peak ) {
|
|
meter.channels[channel].peak = val;
|
|
}
|
|
meter.channels[channel].hold *= falloff_factor;
|
|
if ( val > meter.channels[channel].hold ) {
|
|
meter.channels[channel].hold = val;
|
|
meter.channels[channel].hold_age = 0.0f;
|
|
} else {
|
|
meter.channels[channel].hold_age += 1.0f / static_cast<float>( flags.samplerate );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void update_meter( meter_type & meter, const commandlineflags & flags, std::size_t count, const float * const * buffers ) {
|
|
float falloff_factor = std::pow( 10.0f, -falloff_rate / flags.samplerate / 20.0f );
|
|
for ( int channel = 0; channel < flags.channels; ++channel ) {
|
|
if ( !count ) {
|
|
meter = meter_type();
|
|
}
|
|
meter.channels[channel].peak = 0.0f;
|
|
for ( std::size_t frame = 0; frame < count; ++frame ) {
|
|
if ( meter.channels[channel].clip != 0.0f ) {
|
|
meter.channels[channel].clip -= ( 1.0f / 2.0f ) * 1.0f / static_cast<float>( flags.samplerate );
|
|
if ( meter.channels[channel].clip <= 0.0f ) {
|
|
meter.channels[channel].clip = 0.0f;
|
|
}
|
|
}
|
|
float val = std::fabs( buffers[channel][frame] );
|
|
if ( val >= 1.0f ) {
|
|
meter.channels[channel].clip = 1.0f;
|
|
}
|
|
if ( val > meter.channels[channel].peak ) {
|
|
meter.channels[channel].peak = val;
|
|
}
|
|
meter.channels[channel].hold *= falloff_factor;
|
|
if ( val > meter.channels[channel].hold ) {
|
|
meter.channels[channel].hold = val;
|
|
meter.channels[channel].hold_age = 0.0f;
|
|
} else {
|
|
meter.channels[channel].hold_age += 1.0f / static_cast<float>( flags.samplerate );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static const char * const channel_tags[4][4] = {
|
|
{ " C", " ", " ", " " },
|
|
{ " L", " R", " ", " " },
|
|
{ "FL", "FR", "RC", " " },
|
|
{ "FL", "FR", "RL", "RR" },
|
|
};
|
|
|
|
static std::string channel_to_string( int channels, int channel, const meter_channel & meter, bool tiny = false ) {
|
|
int val = std::numeric_limits<int>::min();
|
|
int hold_pos = std::numeric_limits<int>::min();
|
|
if ( meter.peak > 0.0f ) {
|
|
float db = 20.0f * std::log10( meter.peak );
|
|
val = static_cast<int>( db + 48.0f );
|
|
}
|
|
if ( meter.hold > 0.0f ) {
|
|
float db_hold = 20.0f * std::log10( meter.hold );
|
|
hold_pos = static_cast<int>( db_hold + 48.0f );
|
|
}
|
|
if ( val < 0 ) {
|
|
val = 0;
|
|
}
|
|
int headroom = val;
|
|
if ( val > 48 ) {
|
|
val = 48;
|
|
}
|
|
headroom -= val;
|
|
if ( headroom < 0 ) {
|
|
headroom = 0;
|
|
}
|
|
if ( headroom > 12 ) {
|
|
headroom = 12;
|
|
}
|
|
headroom -= 1; // clip indicator
|
|
if ( headroom < 0 ) {
|
|
headroom = 0;
|
|
}
|
|
if ( tiny ) {
|
|
if ( meter.clip != 0.0f || meter.peak >= 1.0f ) {
|
|
return "#";
|
|
} else if ( meter.peak > std::pow( 10.0f, -6.0f / 20.0f ) ) {
|
|
return "O";
|
|
} else if ( meter.peak > std::pow( 10.0f, -12.0f / 20.0f ) ) {
|
|
return "o";
|
|
} else if ( meter.peak > std::pow( 10.0f, -18.0f / 20.0f ) ) {
|
|
return ".";
|
|
} else {
|
|
return " ";
|
|
}
|
|
} else {
|
|
std::ostringstream res1;
|
|
std::ostringstream res2;
|
|
res1
|
|
<< " "
|
|
<< channel_tags[channels-1][channel]
|
|
<< " : "
|
|
;
|
|
res2
|
|
<< std::string(val,'>') << std::string(std::size_t{48}-val,' ')
|
|
<< ( ( meter.clip != 0.0f ) ? "#" : ":" )
|
|
<< std::string(headroom,'>') << std::string(std::size_t{12}-headroom,' ')
|
|
;
|
|
std::string tmp = res2.str();
|
|
if ( 0 <= hold_pos && hold_pos <= 60 ) {
|
|
if ( hold_pos == 48 ) {
|
|
tmp[hold_pos] = '#';
|
|
} else {
|
|
tmp[hold_pos] = ':';
|
|
}
|
|
}
|
|
return res1.str() + tmp;
|
|
}
|
|
}
|
|
|
|
static char peak_to_char( float peak ) {
|
|
if ( peak >= 1.0f ) {
|
|
return '#';
|
|
} else if ( peak >= 0.5f ) {
|
|
return 'O';
|
|
} else if ( peak >= 0.25f ) {
|
|
return 'o';
|
|
} else if ( peak >= 0.125f ) {
|
|
return '.';
|
|
} else {
|
|
return ' ';
|
|
}
|
|
}
|
|
|
|
static std::string peak_to_string_left( float peak, int width ) {
|
|
std::string result;
|
|
float thresh = 1.0f;
|
|
while ( width-- ) {
|
|
if ( peak >= thresh ) {
|
|
if ( thresh == 1.0f ) {
|
|
result.push_back( '#' );
|
|
} else {
|
|
result.push_back( '<' );
|
|
}
|
|
} else {
|
|
result.push_back( ' ' );
|
|
}
|
|
thresh *= 0.5f;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static std::string peak_to_string_right( float peak, int width ) {
|
|
std::string result;
|
|
float thresh = 1.0f;
|
|
while ( width-- ) {
|
|
if ( peak >= thresh ) {
|
|
if ( thresh == 1.0f ) {
|
|
result.push_back( '#' );
|
|
} else {
|
|
result.push_back( '>' );
|
|
}
|
|
} else {
|
|
result.push_back( ' ' );
|
|
}
|
|
thresh *= 0.5f;
|
|
}
|
|
std::reverse( result.begin(), result.end() );
|
|
return result;
|
|
}
|
|
|
|
static void draw_meters( std::ostream & log, const meter_type & meter, const commandlineflags & flags ) {
|
|
for ( int channel = 0; channel < flags.channels; ++channel ) {
|
|
log << channel_to_string( flags.channels, channel, meter.channels[channel] ) << std::endl;
|
|
}
|
|
}
|
|
|
|
static void draw_meters_tiny( std::ostream & log, const meter_type & meter, const commandlineflags & flags ) {
|
|
for ( int channel = 0; channel < flags.channels; ++channel ) {
|
|
log << channel_to_string( flags.channels, channel, meter.channels[channel], true );
|
|
}
|
|
}
|
|
|
|
static void draw_channel_meters_tiny( std::ostream & log, float peak ) {
|
|
log << peak_to_char( peak );
|
|
}
|
|
|
|
static void draw_channel_meters_tiny( std::ostream & log, float peak_left, float peak_right ) {
|
|
log << peak_to_char( peak_left ) << peak_to_char( peak_right );
|
|
}
|
|
|
|
static void draw_channel_meters( std::ostream & log, float peak_left, float peak_right, int width ) {
|
|
if ( width >= 8 + 1 + 8 ) {
|
|
width = 8 + 1 + 8;
|
|
}
|
|
log << peak_to_string_left( peak_left, width / 2 ) << ( width % 2 == 1 ? ":" : "" ) << peak_to_string_right( peak_right, width / 2 );
|
|
}
|
|
|
|
template < typename Tsample, typename Tmod >
|
|
void render_loop( commandlineflags & flags, Tmod & mod, double & duration, textout & log, write_buffers_interface & audio_stream ) {
|
|
|
|
log.writeout();
|
|
|
|
std::size_t bufsize;
|
|
if ( flags.mode == Mode::UI ) {
|
|
bufsize = std::min( flags.ui_redraw_interval, flags.period ) * flags.samplerate / 1000;
|
|
} else if ( flags.mode == Mode::Batch ) {
|
|
bufsize = flags.period * flags.samplerate / 1000;
|
|
} else {
|
|
bufsize = 1024;
|
|
}
|
|
|
|
std::int64_t last_redraw_frame = std::int64_t{0} - flags.ui_redraw_interval;
|
|
std::int64_t rendered_frames = 0;
|
|
|
|
std::vector<Tsample> left( bufsize );
|
|
std::vector<Tsample> right( bufsize );
|
|
std::vector<Tsample> rear_left( bufsize );
|
|
std::vector<Tsample> rear_right( bufsize );
|
|
std::vector<Tsample*> buffers( 4 ) ;
|
|
buffers[0] = left.data();
|
|
buffers[1] = right.data();
|
|
buffers[2] = rear_left.data();
|
|
buffers[3] = rear_right.data();
|
|
buffers.resize( flags.channels );
|
|
|
|
meter_type meter;
|
|
|
|
const bool multiline = flags.show_ui;
|
|
|
|
int lines = 0;
|
|
|
|
int pattern_lines = 0;
|
|
|
|
if ( multiline ) {
|
|
lines += 1;
|
|
// cppcheck-suppress identicalInnerCondition
|
|
if ( flags.show_ui ) {
|
|
lines += 1;
|
|
}
|
|
if ( flags.show_meters ) {
|
|
for ( int channel = 0; channel < flags.channels; ++channel ) {
|
|
lines += 1;
|
|
}
|
|
}
|
|
if ( flags.show_channel_meters ) {
|
|
lines += 1;
|
|
}
|
|
if ( flags.show_details ) {
|
|
lines += 1;
|
|
if ( flags.show_progress ) {
|
|
lines += 1;
|
|
}
|
|
}
|
|
if ( flags.show_progress ) {
|
|
lines += 1;
|
|
}
|
|
if ( flags.show_pattern ) {
|
|
pattern_lines = flags.terminal_height - lines - 1;
|
|
lines = flags.terminal_height - 1;
|
|
}
|
|
} else if ( flags.show_ui || flags.show_details || flags.show_progress ) {
|
|
log << std::endl;
|
|
}
|
|
for ( int line = 0; line < lines; ++line ) {
|
|
log << std::endl;
|
|
}
|
|
|
|
log.writeout();
|
|
|
|
double cpu_smooth = 0.0;
|
|
|
|
while ( true ) {
|
|
|
|
if ( flags.mode == Mode::UI ) {
|
|
|
|
#if defined( __DJGPP__ )
|
|
|
|
while ( kbhit() ) {
|
|
int c = getch();
|
|
if ( !handle_keypress( c, flags, mod, audio_stream ) ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
#elif defined( WIN32 ) && defined( UNICODE )
|
|
|
|
while ( _kbhit() ) {
|
|
wint_t c = _getwch();
|
|
if ( !handle_keypress( c, flags, mod, audio_stream ) ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
#elif defined( WIN32 )
|
|
|
|
while ( _kbhit() ) {
|
|
int c = _getch();
|
|
if ( !handle_keypress( c, flags, mod, audio_stream ) ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
while ( true ) {
|
|
pollfd pollfds;
|
|
pollfds.fd = STDIN_FILENO;
|
|
pollfds.events = POLLIN;
|
|
poll(&pollfds, 1, 0);
|
|
if ( !( pollfds.revents & POLLIN ) ) {
|
|
break;
|
|
}
|
|
char c = 0;
|
|
if ( read( STDIN_FILENO, &c, 1 ) != 1 ) {
|
|
break;
|
|
}
|
|
if ( !handle_keypress( c, flags, mod, audio_stream ) ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
if ( flags.paused ) {
|
|
audio_stream.sleep( flags.ui_redraw_interval );
|
|
continue;
|
|
}
|
|
|
|
}
|
|
|
|
std::clock_t cpu_beg = 0;
|
|
std::clock_t cpu_end = 0;
|
|
if ( flags.show_details ) {
|
|
cpu_beg = std::clock();
|
|
}
|
|
|
|
std::size_t count = 0;
|
|
|
|
switch ( flags.channels ) {
|
|
case 1: count = mod.read( flags.samplerate, bufsize, left.data() ); break;
|
|
case 2: count = mod.read( flags.samplerate, bufsize, left.data(), right.data() ); break;
|
|
case 4: count = mod.read( flags.samplerate, bufsize, left.data(), right.data(), rear_left.data(), rear_right.data() ); break;
|
|
}
|
|
|
|
char cpu_str[64] = "";
|
|
if ( flags.show_details ) {
|
|
cpu_end = std::clock();
|
|
if ( count > 0 ) {
|
|
double cpu = 1.0;
|
|
cpu *= ( static_cast<double>( cpu_end ) - static_cast<double>( cpu_beg ) ) / static_cast<double>( CLOCKS_PER_SEC );
|
|
cpu /= ( static_cast<double>( count ) ) / static_cast<double>( flags.samplerate );
|
|
double mix = ( static_cast<double>( count ) ) / static_cast<double>( flags.samplerate );
|
|
cpu_smooth = ( 1.0 - mix ) * cpu_smooth + mix * cpu;
|
|
std::snprintf( cpu_str, 64, "%.2f%%", cpu_smooth * 100.0 );
|
|
}
|
|
}
|
|
|
|
if ( flags.show_meters ) {
|
|
update_meter( meter, flags, count, buffers.data() );
|
|
}
|
|
|
|
if ( count > 0 ) {
|
|
audio_stream.write( buffers, count );
|
|
}
|
|
|
|
if ( count > 0 ) {
|
|
rendered_frames += count;
|
|
if ( rendered_frames >= last_redraw_frame + ( flags.ui_redraw_interval * flags.samplerate / 1000 ) ) {
|
|
last_redraw_frame = rendered_frames;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( multiline ) {
|
|
log.cursor_up( lines );
|
|
log << std::endl;
|
|
if ( flags.show_meters ) {
|
|
draw_meters( log, meter, flags );
|
|
}
|
|
if ( flags.show_channel_meters ) {
|
|
int width = ( flags.terminal_width - 3 ) / mod.get_num_channels();
|
|
if ( width > 11 ) {
|
|
width = 11;
|
|
}
|
|
log << " ";
|
|
for ( std::int32_t channel = 0; channel < mod.get_num_channels(); ++channel ) {
|
|
if ( width >= 3 ) {
|
|
log << ":";
|
|
}
|
|
if ( width == 1 ) {
|
|
draw_channel_meters_tiny( log, ( mod.get_current_channel_vu_left( channel ) + mod.get_current_channel_vu_right( channel ) ) * (1.0f/std::sqrt(2.0f)) );
|
|
} else if ( width <= 4 ) {
|
|
draw_channel_meters_tiny( log, mod.get_current_channel_vu_left( channel ), mod.get_current_channel_vu_right( channel ) );
|
|
} else {
|
|
draw_channel_meters( log, mod.get_current_channel_vu_left( channel ), mod.get_current_channel_vu_right( channel ), width - 1 );
|
|
}
|
|
}
|
|
if ( width >= 3 ) {
|
|
log << ":";
|
|
}
|
|
log << std::endl;
|
|
}
|
|
if ( flags.show_pattern ) {
|
|
int width = ( flags.terminal_width - 3 ) / mod.get_num_channels();
|
|
if ( width > 13 + 1 ) {
|
|
width = 13 + 1;
|
|
}
|
|
for ( std::int32_t line = 0; line < pattern_lines; ++line ) {
|
|
std::int32_t row = mod.get_current_row() - ( pattern_lines / 2 ) + line;
|
|
if ( row == mod.get_current_row() ) {
|
|
log << ">";
|
|
} else {
|
|
log << " ";
|
|
}
|
|
if ( row < 0 || row >= mod.get_pattern_num_rows( mod.get_current_pattern() ) ) {
|
|
for ( std::int32_t channel = 0; channel < mod.get_num_channels(); ++channel ) {
|
|
if ( width >= 3 ) {
|
|
log << ":";
|
|
}
|
|
log << std::string( width >= 3 ? width - 1 : width, ' ' );
|
|
}
|
|
} else {
|
|
for ( std::int32_t channel = 0; channel < mod.get_num_channels(); ++channel ) {
|
|
if ( width >= 3 ) {
|
|
if ( row == mod.get_current_row() ) {
|
|
log << "+";
|
|
} else {
|
|
log << ":";
|
|
}
|
|
}
|
|
log << mod.format_pattern_row_channel( mod.get_current_pattern(), row, channel, width >= 3 ? width - 1 : width );
|
|
}
|
|
}
|
|
if ( width >= 3 ) {
|
|
log << ":";
|
|
}
|
|
log << std::endl;
|
|
}
|
|
}
|
|
if ( flags.show_ui ) {
|
|
log << "Settings...: ";
|
|
log << "Gain: " << flags.gain * 0.01f << " dB" << " ";
|
|
log << "Stereo: " << flags.separation << " %" << " ";
|
|
log << "Filter: " << flags.filtertaps << " taps" << " ";
|
|
log << "Ramping: " << flags.ramping << " ";
|
|
log << std::endl;
|
|
}
|
|
if ( flags.show_details ) {
|
|
log << "Mixer......: ";
|
|
log << "CPU:" << std::setw(6) << std::setfill(':') << cpu_str;
|
|
log << " ";
|
|
log << "Chn:" << std::setw(3) << std::setfill(':') << mod.get_current_playing_channels();
|
|
log << " ";
|
|
log << std::endl;
|
|
if ( flags.show_progress ) {
|
|
log << "Player.....: ";
|
|
log << "Ord:" << std::setw(3) << std::setfill(':') << mod.get_current_order() << "/" << std::setw(3) << std::setfill(':') << mod.get_num_orders();
|
|
log << " ";
|
|
log << "Pat:" << std::setw(3) << std::setfill(':') << mod.get_current_pattern();
|
|
log << " ";
|
|
log << "Row:" << std::setw(3) << std::setfill(':') << mod.get_current_row();
|
|
log << " ";
|
|
log << "Spd:" << std::setw(2) << std::setfill(':') << mod.get_current_speed();
|
|
log << " ";
|
|
log << "Tmp:" << std::setw(3) << std::setfill(':') << mod.get_current_tempo();
|
|
log << " ";
|
|
log << std::endl;
|
|
}
|
|
}
|
|
if ( flags.show_progress ) {
|
|
log << "Position...: " << seconds_to_string( mod.get_position_seconds() ) << " / " << seconds_to_string( duration ) << " " << std::endl;
|
|
}
|
|
} else if ( flags.show_channel_meters ) {
|
|
if ( flags.show_ui || flags.show_details || flags.show_progress ) {
|
|
int width = ( flags.terminal_width - 3 ) / mod.get_num_channels();
|
|
log << " ";
|
|
for ( std::int32_t channel = 0; channel < mod.get_num_channels(); ++channel ) {
|
|
if ( width >= 3 ) {
|
|
log << ":";
|
|
}
|
|
if ( width == 1 ) {
|
|
draw_channel_meters_tiny( log, ( mod.get_current_channel_vu_left( channel ) + mod.get_current_channel_vu_right( channel ) ) * (1.0f/std::sqrt(2.0f)) );
|
|
} else if ( width <= 4 ) {
|
|
draw_channel_meters_tiny( log, mod.get_current_channel_vu_left( channel ), mod.get_current_channel_vu_right( channel ) );
|
|
} else {
|
|
draw_channel_meters( log, mod.get_current_channel_vu_left( channel ), mod.get_current_channel_vu_right( channel ), width - 1 );
|
|
}
|
|
}
|
|
if ( width >= 3 ) {
|
|
log << ":";
|
|
}
|
|
}
|
|
log << " " << "\r";
|
|
} else {
|
|
if ( flags.show_ui ) {
|
|
log << " ";
|
|
log << std::setw(3) << std::setfill(':') << flags.gain * 0.01f << "dB";
|
|
log << "|";
|
|
log << std::setw(3) << std::setfill(':') << flags.separation << "%";
|
|
log << "|";
|
|
log << std::setw(2) << std::setfill(':') << flags.filtertaps << "taps";
|
|
log << "|";
|
|
log << std::setw(3) << std::setfill(':') << flags.ramping;
|
|
}
|
|
if ( flags.show_meters ) {
|
|
log << " ";
|
|
draw_meters_tiny( log, meter, flags );
|
|
}
|
|
if ( flags.show_details && flags.show_ui ) {
|
|
log << " ";
|
|
log << "CPU:" << std::setw(6) << std::setfill(':') << cpu_str;
|
|
log << "|";
|
|
log << "Chn:" << std::setw(3) << std::setfill(':') << mod.get_current_playing_channels();
|
|
}
|
|
if ( flags.show_details && !flags.show_ui ) {
|
|
if ( flags.show_progress ) {
|
|
log << " ";
|
|
log << "Ord:" << std::setw(3) << std::setfill(':') << mod.get_current_order() << "/" << std::setw(3) << std::setfill(':') << mod.get_num_orders();
|
|
log << "|";
|
|
log << "Pat:" << std::setw(3) << std::setfill(':') << mod.get_current_pattern();
|
|
log << "|";
|
|
log << "Row:" << std::setw(3) << std::setfill(':') << mod.get_current_row();
|
|
log << " ";
|
|
log << "Spd:" << std::setw(2) << std::setfill(':') << mod.get_current_speed();
|
|
log << "|";
|
|
log << "Tmp:" << std::setw(3) << std::setfill(':') << mod.get_current_tempo();
|
|
}
|
|
}
|
|
if ( flags.show_progress ) {
|
|
log << " ";
|
|
log << seconds_to_string( mod.get_position_seconds() );
|
|
log << "/";
|
|
log << seconds_to_string( duration );
|
|
}
|
|
if ( flags.show_ui || flags.show_details || flags.show_progress ) {
|
|
log << " " << "\r";
|
|
}
|
|
}
|
|
|
|
log.writeout();
|
|
|
|
if ( count == 0 ) {
|
|
break;
|
|
}
|
|
|
|
if ( flags.end_time > 0 && mod.get_position_seconds() >= flags.end_time ) {
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
log.writeout();
|
|
|
|
}
|
|
|
|
template < typename Tmod >
|
|
std::map<std::string,std::string> get_metadata( const Tmod & mod ) {
|
|
std::map<std::string,std::string> result;
|
|
const std::vector<std::string> metadata_keys = mod.get_metadata_keys();
|
|
for ( const auto & key : metadata_keys ) {
|
|
result[ key ] = mod.get_metadata( key );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
class set_field : private std::ostringstream {
|
|
private:
|
|
std::vector<openmpt123::field> & fields;
|
|
public:
|
|
set_field( std::vector<openmpt123::field> & fields, const std::string & name )
|
|
: fields(fields)
|
|
{
|
|
fields.push_back( name );
|
|
}
|
|
std::ostream & ostream() {
|
|
return *this;
|
|
}
|
|
~set_field() {
|
|
fields.back().val = str();
|
|
}
|
|
};
|
|
|
|
static void show_fields( textout & log, const std::vector<field> & fields ) {
|
|
const std::size_t fw = 11;
|
|
for ( const auto & field :fields ) {
|
|
std::string key = field.key;
|
|
std::string val = field.val;
|
|
if ( key.length() < fw ) {
|
|
key += std::string( fw - key.length(), '.' );
|
|
}
|
|
if ( key.length() > fw ) {
|
|
key = key.substr( 0, fw );
|
|
}
|
|
key += ": ";
|
|
val = prepend_lines( val, std::string( fw, ' ' ) + ": " );
|
|
log << key << val << std::endl;
|
|
}
|
|
}
|
|
|
|
static void probe_mod_file( commandlineflags & flags, const std::string & filename, std::uint64_t filesize, std::istream & data_stream, textout & log ) {
|
|
|
|
log.writeout();
|
|
|
|
std::vector<field> fields;
|
|
|
|
if ( flags.filenames.size() > 1 ) {
|
|
set_field( fields, "Playlist" ).ostream() << flags.playlist_index + 1 << "/" << flags.filenames.size();
|
|
set_field( fields, "Prev/Next" ).ostream()
|
|
<< "'"
|
|
<< ( flags.playlist_index > 0 ? get_filename( flags.filenames[ flags.playlist_index - 1 ] ) : std::string() )
|
|
<< "'"
|
|
<< " / "
|
|
<< "['" << get_filename( filename ) << "']"
|
|
<< " / "
|
|
<< "'"
|
|
<< ( flags.playlist_index + 1 < flags.filenames.size() ? get_filename( flags.filenames[ flags.playlist_index + 1 ] ) : std::string() )
|
|
<< "'"
|
|
;
|
|
}
|
|
if ( flags.verbose ) {
|
|
set_field( fields, "Path" ).ostream() << filename;
|
|
}
|
|
if ( flags.show_details ) {
|
|
set_field( fields, "Filename" ).ostream() << get_filename( filename );
|
|
set_field( fields, "Size" ).ostream() << bytes_to_string( filesize );
|
|
}
|
|
|
|
int probe_result = openmpt::probe_file_header( openmpt::probe_file_header_flags_default2, data_stream );
|
|
std::string probe_result_string;
|
|
switch ( probe_result ) {
|
|
case openmpt::probe_file_header_result_success:
|
|
probe_result_string = "Success";
|
|
break;
|
|
case openmpt::probe_file_header_result_failure:
|
|
probe_result_string = "Failure";
|
|
break;
|
|
case openmpt::probe_file_header_result_wantmoredata:
|
|
probe_result_string = "Insufficient Data";
|
|
break;
|
|
default:
|
|
probe_result_string = "Internal Error";
|
|
break;
|
|
}
|
|
set_field( fields, "Probe" ).ostream() << probe_result_string;
|
|
|
|
show_fields( log, fields );
|
|
|
|
log.writeout();
|
|
|
|
}
|
|
|
|
template < typename Tmod >
|
|
void render_mod_file( commandlineflags & flags, const std::string & filename, std::uint64_t filesize, Tmod & mod, textout & log, write_buffers_interface & audio_stream ) {
|
|
|
|
log.writeout();
|
|
|
|
if ( flags.mode != Mode::Probe && flags.mode != Mode::Info ) {
|
|
mod.set_repeat_count( flags.repeatcount );
|
|
apply_mod_settings( flags, mod );
|
|
}
|
|
|
|
double duration = mod.get_duration_seconds();
|
|
|
|
std::vector<field> fields;
|
|
|
|
if ( flags.filenames.size() > 1 ) {
|
|
set_field( fields, "Playlist" ).ostream() << flags.playlist_index + 1 << "/" << flags.filenames.size();
|
|
set_field( fields, "Prev/Next" ).ostream()
|
|
<< "'"
|
|
<< ( flags.playlist_index > 0 ? get_filename( flags.filenames[ flags.playlist_index - 1 ] ) : std::string() )
|
|
<< "'"
|
|
<< " / "
|
|
<< "['" << get_filename( filename ) << "']"
|
|
<< " / "
|
|
<< "'"
|
|
<< ( flags.playlist_index + 1 < flags.filenames.size() ? get_filename( flags.filenames[ flags.playlist_index + 1 ] ) : std::string() )
|
|
<< "'"
|
|
;
|
|
}
|
|
if ( flags.verbose ) {
|
|
set_field( fields, "Path" ).ostream() << filename;
|
|
}
|
|
if ( flags.show_details ) {
|
|
set_field( fields, "Filename" ).ostream() << get_filename( filename );
|
|
set_field( fields, "Size" ).ostream() << bytes_to_string( filesize );
|
|
if ( !mod.get_metadata( "warnings" ).empty() ) {
|
|
set_field( fields, "Warnings" ).ostream() << mod.get_metadata( "warnings" );
|
|
}
|
|
if ( !mod.get_metadata( "container" ).empty() ) {
|
|
set_field( fields, "Container" ).ostream() << mod.get_metadata( "container" ) << " (" << mod.get_metadata( "container_long" ) << ")";
|
|
}
|
|
set_field( fields, "Type" ).ostream() << mod.get_metadata( "type" ) << " (" << mod.get_metadata( "type_long" ) << ")";
|
|
if ( !mod.get_metadata( "originaltype" ).empty() ) {
|
|
set_field( fields, "Orig. Type" ).ostream() << mod.get_metadata( "originaltype" ) << " (" << mod.get_metadata( "originaltype_long" ) << ")";
|
|
}
|
|
if ( ( mod.get_num_subsongs() > 1 ) && ( flags.subsong != -1 ) ) {
|
|
set_field( fields, "Subsong" ).ostream() << flags.subsong;
|
|
}
|
|
set_field( fields, "Tracker" ).ostream() << mod.get_metadata( "tracker" );
|
|
if ( !mod.get_metadata( "date" ).empty() ) {
|
|
set_field( fields, "Date" ).ostream() << mod.get_metadata( "date" );
|
|
}
|
|
if ( !mod.get_metadata( "artist" ).empty() ) {
|
|
set_field( fields, "Artist" ).ostream() << mod.get_metadata( "artist" );
|
|
}
|
|
}
|
|
if ( true ) {
|
|
set_field( fields, "Title" ).ostream() << mod.get_metadata( "title" );
|
|
set_field( fields, "Duration" ).ostream() << seconds_to_string( duration );
|
|
}
|
|
if ( flags.show_details ) {
|
|
set_field( fields, "Subsongs" ).ostream() << mod.get_num_subsongs();
|
|
set_field( fields, "Channels" ).ostream() << mod.get_num_channels();
|
|
set_field( fields, "Orders" ).ostream() << mod.get_num_orders();
|
|
set_field( fields, "Patterns" ).ostream() << mod.get_num_patterns();
|
|
set_field( fields, "Instruments" ).ostream() << mod.get_num_instruments();
|
|
set_field( fields, "Samples" ).ostream() << mod.get_num_samples();
|
|
}
|
|
if ( flags.show_message ) {
|
|
set_field( fields, "Message" ).ostream() << mod.get_metadata( "message" );
|
|
}
|
|
|
|
show_fields( log, fields );
|
|
|
|
log.writeout();
|
|
|
|
if ( flags.filenames.size() == 1 || flags.mode == Mode::Render ) {
|
|
audio_stream.write_metadata( get_metadata( mod ) );
|
|
} else {
|
|
audio_stream.write_updated_metadata( get_metadata( mod ) );
|
|
}
|
|
|
|
if ( flags.mode == Mode::Probe || flags.mode == Mode::Info ) {
|
|
return;
|
|
}
|
|
|
|
if ( flags.seek_target > 0.0 ) {
|
|
mod.set_position_seconds( flags.seek_target );
|
|
}
|
|
|
|
try {
|
|
if ( flags.use_float ) {
|
|
render_loop<float>( flags, mod, duration, log, audio_stream );
|
|
} else {
|
|
render_loop<std::int16_t>( flags, mod, duration, log, audio_stream );
|
|
}
|
|
if ( flags.show_progress ) {
|
|
log << std::endl;
|
|
}
|
|
} catch ( ... ) {
|
|
if ( flags.show_progress ) {
|
|
log << std::endl;
|
|
}
|
|
throw;
|
|
}
|
|
|
|
log.writeout();
|
|
|
|
}
|
|
|
|
static void probe_file( commandlineflags & flags, const std::string & filename, textout & log ) {
|
|
|
|
log.writeout();
|
|
|
|
std::ostringstream silentlog;
|
|
|
|
try {
|
|
|
|
#if defined(WIN32) && defined(UNICODE) && !defined(_MSC_VER)
|
|
std::istringstream file_stream;
|
|
#else
|
|
std::ifstream file_stream;
|
|
#endif
|
|
std::uint64_t filesize = 0;
|
|
bool use_stdin = ( filename == "-" );
|
|
if ( !use_stdin ) {
|
|
#if defined(WIN32) && defined(UNICODE) && !defined(_MSC_VER)
|
|
// Only MSVC has std::ifstream::ifstream(std::wstring).
|
|
// Fake it for other compilers using _wfopen().
|
|
std::string data;
|
|
FILE * f = _wfopen( mpt::transcode<std::wstring>( mpt::common_encoding::utf8, filename ).c_str(), L"rb" );
|
|
if ( f ) {
|
|
while ( !feof( f ) ) {
|
|
static const std::size_t BUFFER_SIZE = 4096;
|
|
char buffer[BUFFER_SIZE];
|
|
size_t data_read = fread( buffer, 1, BUFFER_SIZE, f );
|
|
std::copy( buffer, buffer + data_read, std::back_inserter( data ) );
|
|
}
|
|
fclose( f );
|
|
f = NULL;
|
|
}
|
|
file_stream.str( data );
|
|
filesize = data.length();
|
|
#elif defined(_MSC_VER) && defined(UNICODE)
|
|
file_stream.open( mpt::transcode<std::wstring>( mpt::common_encoding::utf8, filename ), std::ios::binary );
|
|
file_stream.seekg( 0, std::ios::end );
|
|
filesize = file_stream.tellg();
|
|
file_stream.seekg( 0, std::ios::beg );
|
|
#else
|
|
file_stream.open( filename, std::ios::binary );
|
|
file_stream.seekg( 0, std::ios::end );
|
|
filesize = file_stream.tellg();
|
|
file_stream.seekg( 0, std::ios::beg );
|
|
#endif
|
|
}
|
|
std::istream & data_stream = use_stdin ? std::cin : file_stream;
|
|
if ( data_stream.fail() ) {
|
|
throw exception( "file open error" );
|
|
}
|
|
|
|
probe_mod_file( flags, filename, filesize, data_stream, log );
|
|
|
|
} catch ( silent_exit_exception & ) {
|
|
throw;
|
|
} catch ( std::exception & e ) {
|
|
if ( !silentlog.str().empty() ) {
|
|
log << "errors probing '" << filename << "': " << silentlog.str() << std::endl;
|
|
} else {
|
|
log << "errors probing '" << filename << "'" << std::endl;
|
|
}
|
|
log << "error probing '" << filename << "': " << e.what() << std::endl;
|
|
} catch ( ... ) {
|
|
if ( !silentlog.str().empty() ) {
|
|
log << "errors probing '" << filename << "': " << silentlog.str() << std::endl;
|
|
} else {
|
|
log << "errors probing '" << filename << "'" << std::endl;
|
|
}
|
|
log << "unknown error probing '" << filename << "'" << std::endl;
|
|
}
|
|
|
|
log << std::endl;
|
|
|
|
log.writeout();
|
|
|
|
}
|
|
|
|
static void render_file( commandlineflags & flags, const std::string & filename, textout & log, write_buffers_interface & audio_stream ) {
|
|
|
|
log.writeout();
|
|
|
|
std::ostringstream silentlog;
|
|
|
|
try {
|
|
|
|
#if defined(WIN32) && defined(UNICODE) && !defined(_MSC_VER)
|
|
std::istringstream file_stream;
|
|
#else
|
|
std::ifstream file_stream;
|
|
#endif
|
|
std::uint64_t filesize = 0;
|
|
bool use_stdin = ( filename == "-" );
|
|
if ( !use_stdin ) {
|
|
#if defined(WIN32) && defined(UNICODE) && !defined(_MSC_VER)
|
|
// Only MSVC has std::ifstream::ifstream(std::wstring).
|
|
// Fake it for other compilers using _wfopen().
|
|
std::string data;
|
|
FILE * f = _wfopen( mpt::transcode<std::wstring>( mpt::common_encoding::utf8, filename ).c_str(), L"rb" );
|
|
if ( f ) {
|
|
while ( !feof( f ) ) {
|
|
static const std::size_t BUFFER_SIZE = 4096;
|
|
char buffer[BUFFER_SIZE];
|
|
size_t data_read = fread( buffer, 1, BUFFER_SIZE, f );
|
|
std::copy( buffer, buffer + data_read, std::back_inserter( data ) );
|
|
}
|
|
fclose( f );
|
|
f = NULL;
|
|
}
|
|
file_stream.str( data );
|
|
filesize = data.length();
|
|
#elif defined(_MSC_VER) && defined(UNICODE)
|
|
file_stream.open( mpt::transcode<std::wstring>( mpt::common_encoding::utf8, filename ), std::ios::binary );
|
|
file_stream.seekg( 0, std::ios::end );
|
|
filesize = file_stream.tellg();
|
|
file_stream.seekg( 0, std::ios::beg );
|
|
#else
|
|
file_stream.open( filename, std::ios::binary );
|
|
file_stream.seekg( 0, std::ios::end );
|
|
filesize = file_stream.tellg();
|
|
file_stream.seekg( 0, std::ios::beg );
|
|
#endif
|
|
}
|
|
std::istream & data_stream = use_stdin ? std::cin : file_stream;
|
|
if ( data_stream.fail() ) {
|
|
throw exception( "file open error" );
|
|
}
|
|
|
|
{
|
|
openmpt::module mod( data_stream, silentlog, flags.ctls );
|
|
mod.select_subsong( flags.subsong );
|
|
silentlog.str( std::string() ); // clear, loader messages get stored to get_metadata( "warnings" ) by libopenmpt internally
|
|
render_mod_file( flags, filename, filesize, mod, log, audio_stream );
|
|
}
|
|
|
|
} catch ( prev_file & ) {
|
|
throw;
|
|
} catch ( next_file & ) {
|
|
throw;
|
|
} catch ( silent_exit_exception & ) {
|
|
throw;
|
|
} catch ( std::exception & e ) {
|
|
if ( !silentlog.str().empty() ) {
|
|
log << "errors loading '" << filename << "': " << silentlog.str() << std::endl;
|
|
} else {
|
|
log << "errors loading '" << filename << "'" << std::endl;
|
|
}
|
|
log << "error playing '" << filename << "': " << e.what() << std::endl;
|
|
} catch ( ... ) {
|
|
if ( !silentlog.str().empty() ) {
|
|
log << "errors loading '" << filename << "': " << silentlog.str() << std::endl;
|
|
} else {
|
|
log << "errors loading '" << filename << "'" << std::endl;
|
|
}
|
|
log << "unknown error playing '" << filename << "'" << std::endl;
|
|
}
|
|
|
|
log << std::endl;
|
|
|
|
log.writeout();
|
|
|
|
}
|
|
|
|
|
|
static std::string get_random_filename( std::set<std::string> & filenames, std::default_random_engine & prng ) {
|
|
std::size_t index = std::uniform_int_distribution<std::size_t>( 0, filenames.size() - 1 )( prng );
|
|
std::set<std::string>::iterator it = filenames.begin();
|
|
std::advance( it, index );
|
|
return *it;
|
|
}
|
|
|
|
|
|
static void render_files( commandlineflags & flags, textout & log, write_buffers_interface & audio_stream, std::default_random_engine & prng ) {
|
|
if ( flags.randomize ) {
|
|
std::shuffle( flags.filenames.begin(), flags.filenames.end(), prng );
|
|
}
|
|
try {
|
|
while ( true ) {
|
|
if ( flags.shuffle ) {
|
|
// TODO: improve prev/next logic
|
|
std::set<std::string> shuffle_set;
|
|
shuffle_set.insert( flags.filenames.begin(), flags.filenames.end() );
|
|
while ( true ) {
|
|
if ( shuffle_set.empty() ) {
|
|
break;
|
|
}
|
|
std::string filename = get_random_filename( shuffle_set, prng );
|
|
try {
|
|
flags.playlist_index = std::find( flags.filenames.begin(), flags.filenames.end(), filename ) - flags.filenames.begin();
|
|
render_file( flags, filename, log, audio_stream );
|
|
shuffle_set.erase( filename );
|
|
continue;
|
|
} catch ( prev_file & ) {
|
|
shuffle_set.erase( filename );
|
|
continue;
|
|
} catch ( next_file & ) {
|
|
shuffle_set.erase( filename );
|
|
continue;
|
|
} catch ( ... ) {
|
|
throw;
|
|
}
|
|
}
|
|
} else {
|
|
std::vector<std::string>::iterator filename = flags.filenames.begin();
|
|
while ( true ) {
|
|
if ( filename == flags.filenames.end() ) {
|
|
break;
|
|
}
|
|
try {
|
|
flags.playlist_index = filename - flags.filenames.begin();
|
|
render_file( flags, *filename, log, audio_stream );
|
|
filename++;
|
|
continue;
|
|
} catch ( prev_file & e ) {
|
|
while ( filename != flags.filenames.begin() && e.count ) {
|
|
e.count--;
|
|
--filename;
|
|
}
|
|
continue;
|
|
} catch ( next_file & e ) {
|
|
while ( filename != flags.filenames.end() && e.count ) {
|
|
e.count--;
|
|
++filename;
|
|
}
|
|
continue;
|
|
} catch ( ... ) {
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
if ( !flags.restart ) {
|
|
break;
|
|
}
|
|
}
|
|
} catch ( ... ) {
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
static bool parse_playlist( commandlineflags & flags, std::string filename, std::ostream & log ) {
|
|
log.flush();
|
|
bool is_playlist = false;
|
|
bool m3u8 = false;
|
|
if ( ends_with( filename, ".m3u") || ends_with( filename, ".m3U") || ends_with( filename, ".M3u") || ends_with( filename, ".M3U") ) {
|
|
is_playlist = true;
|
|
}
|
|
if ( ends_with( filename, ".m3u8") || ends_with( filename, ".m3U8") || ends_with( filename, ".M3u8") || ends_with( filename, ".M3U8") ) {
|
|
is_playlist = true;
|
|
m3u8 = true;
|
|
}
|
|
if ( ends_with( filename, ".pls") || ends_with( filename, ".plS") || ends_with( filename, ".pLs") || ends_with( filename, ".pLS") || ends_with( filename, ".Pls") || ends_with( filename, ".PlS") || ends_with( filename, ".PLs") || ends_with( filename, ".PLS") ) {
|
|
is_playlist = true;
|
|
}
|
|
std::string basepath = get_basepath( filename );
|
|
try {
|
|
#if defined(WIN32) && defined(UNICODE) && !defined(_MSC_VER)
|
|
std::istringstream file_stream;
|
|
#else
|
|
std::ifstream file_stream;
|
|
#endif
|
|
#if defined(WIN32) && defined(UNICODE) && !defined(_MSC_VER)
|
|
// Only MSVC has std::ifstream::ifstream(std::wstring).
|
|
// Fake it for other compilers using _wfopen().
|
|
std::string data;
|
|
FILE * f = _wfopen( mpt::transcode<std::wstring>( mpt::common_encoding::utf8, filename ).c_str(), L"rb" );
|
|
if ( f ) {
|
|
while ( !feof( f ) ) {
|
|
static const std::size_t BUFFER_SIZE = 4096;
|
|
char buffer[BUFFER_SIZE];
|
|
size_t data_read = fread( buffer, 1, BUFFER_SIZE, f );
|
|
std::copy( buffer, buffer + data_read, std::back_inserter( data ) );
|
|
}
|
|
fclose( f );
|
|
f = NULL;
|
|
}
|
|
file_stream.str( data );
|
|
#elif defined(_MSC_VER) && defined(UNICODE)
|
|
file_stream.open( mpt::transcode<std::wstring>( mpt::common_encoding::utf8, filename ), std::ios::binary );
|
|
#else
|
|
file_stream.open( filename, std::ios::binary );
|
|
#endif
|
|
std::string line;
|
|
bool first = true;
|
|
bool extm3u = false;
|
|
bool pls = false;
|
|
while ( std::getline( file_stream, line ) ) {
|
|
std::string newfile;
|
|
line = trim_eol( line );
|
|
if ( first ) {
|
|
first = false;
|
|
if ( line == "#EXTM3U" ) {
|
|
extm3u = true;
|
|
continue;
|
|
} else if ( line == "[playlist]" ) {
|
|
pls = true;
|
|
}
|
|
}
|
|
if ( line.empty() ) {
|
|
continue;
|
|
}
|
|
if ( pls ) {
|
|
if ( begins_with( line, "File" ) ) {
|
|
if ( line.find( "=" ) != std::string::npos ) {
|
|
flags.filenames.push_back( line.substr( line.find( "=" ) + 1 ) );
|
|
}
|
|
} else if ( begins_with( line, "Title" ) ) {
|
|
continue;
|
|
} else if ( begins_with( line, "Length" ) ) {
|
|
continue;
|
|
} else if ( begins_with( line, "NumberOfEntries" ) ) {
|
|
continue;
|
|
} else if ( begins_with( line, "Version" ) ) {
|
|
continue;
|
|
} else {
|
|
continue;
|
|
}
|
|
} else if ( extm3u ) {
|
|
if ( begins_with( line, "#EXTINF" ) ) {
|
|
continue;
|
|
} else if ( begins_with( line, "#" ) ) {
|
|
continue;
|
|
}
|
|
if ( m3u8 ) {
|
|
newfile = line;
|
|
} else {
|
|
#if defined(WIN32)
|
|
newfile = mpt::transcode<std::string>( mpt::common_encoding::utf8, mpt::logical_encoding::locale, line );
|
|
#else
|
|
newfile = line;
|
|
#endif
|
|
}
|
|
} else {
|
|
if ( m3u8 ) {
|
|
newfile = line;
|
|
} else {
|
|
#if defined(WIN32)
|
|
newfile = mpt::transcode<std::string>( mpt::common_encoding::utf8, mpt::logical_encoding::locale, line );
|
|
#else
|
|
newfile = line;
|
|
#endif
|
|
}
|
|
}
|
|
if ( !newfile.empty() ) {
|
|
if ( !is_absolute( newfile ) ) {
|
|
newfile = basepath + newfile;
|
|
}
|
|
flags.filenames.push_back( newfile );
|
|
}
|
|
}
|
|
} catch ( std::exception & e ) {
|
|
log << "error loading '" << filename << "': " << e.what() << std::endl;
|
|
} catch ( ... ) {
|
|
log << "unknown error loading '" << filename << "'" << std::endl;
|
|
}
|
|
log.flush();
|
|
return is_playlist;
|
|
}
|
|
|
|
|
|
static commandlineflags parse_openmpt123( const std::vector<std::string> & args, std::ostream & log ) {
|
|
|
|
log.flush();
|
|
|
|
if ( args.size() <= 1 ) {
|
|
throw args_error_exception();
|
|
}
|
|
|
|
commandlineflags flags;
|
|
|
|
bool files_only = false;
|
|
// cppcheck false-positive
|
|
// cppcheck-suppress StlMissingComparison
|
|
for ( auto i = args.begin(); i != args.end(); ++i ) {
|
|
if ( i == args.begin() ) {
|
|
// skip program name
|
|
continue;
|
|
}
|
|
std::string arg = *i;
|
|
std::string nextarg = ( i+1 != args.end() ) ? *(i+1) : "";
|
|
if ( files_only ) {
|
|
flags.filenames.push_back( arg );
|
|
} else if ( arg.substr( 0, 1 ) != "-" ) {
|
|
flags.filenames.push_back( arg );
|
|
} else {
|
|
if ( arg == "--" ) {
|
|
files_only = true;
|
|
} else if ( arg == "-h" || arg == "--help" ) {
|
|
throw show_help_exception();
|
|
} else if ( arg == "--help-keyboard" ) {
|
|
throw show_help_keyboard_exception();
|
|
} else if ( arg == "-q" || arg == "--quiet" ) {
|
|
flags.quiet = true;
|
|
} else if ( arg == "-v" || arg == "--verbose" ) {
|
|
flags.verbose = true;
|
|
} else if ( arg == "--man-version" ) {
|
|
throw show_man_version_exception();
|
|
} else if ( arg == "--man-help" ) {
|
|
throw show_man_help_exception();
|
|
} else if ( arg == "--version" ) {
|
|
throw show_version_number_exception();
|
|
} else if ( arg == "--short-version" ) {
|
|
throw show_short_version_number_exception();
|
|
} else if ( arg == "--long-version" ) {
|
|
throw show_long_version_number_exception();
|
|
} else if ( arg == "--credits" ) {
|
|
throw show_credits_exception();
|
|
} else if ( arg == "--license" ) {
|
|
throw show_license_exception();
|
|
} else if ( arg == "--probe" ) {
|
|
flags.mode = Mode::Probe;
|
|
} else if ( arg == "--info" ) {
|
|
flags.mode = Mode::Info;
|
|
} else if ( arg == "--ui" ) {
|
|
flags.mode = Mode::UI;
|
|
} else if ( arg == "--batch" ) {
|
|
flags.mode = Mode::Batch;
|
|
} else if ( arg == "--render" ) {
|
|
flags.mode = Mode::Render;
|
|
} else if ( arg == "--terminal-width" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.terminal_width;
|
|
++i;
|
|
} else if ( arg == "--terminal-height" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.terminal_height;
|
|
++i;
|
|
} else if ( arg == "--progress" ) {
|
|
flags.show_progress = true;
|
|
} else if ( arg == "--no-progress" ) {
|
|
flags.show_progress = false;
|
|
} else if ( arg == "--meters" ) {
|
|
flags.show_meters = true;
|
|
} else if ( arg == "--no-meters" ) {
|
|
flags.show_meters = false;
|
|
} else if ( arg == "--channel-meters" ) {
|
|
flags.show_channel_meters = true;
|
|
} else if ( arg == "--no-channel-meters" ) {
|
|
flags.show_channel_meters = false;
|
|
} else if ( arg == "--pattern" ) {
|
|
flags.show_pattern = true;
|
|
} else if ( arg == "--no-pattern" ) {
|
|
flags.show_pattern = false;
|
|
} else if ( arg == "--details" ) {
|
|
flags.show_details = true;
|
|
} else if ( arg == "--no-details" ) {
|
|
flags.show_details = false;
|
|
} else if ( arg == "--message" ) {
|
|
flags.show_message = true;
|
|
} else if ( arg == "--no-message" ) {
|
|
flags.show_message = false;
|
|
} else if ( arg == "--driver" && nextarg != "" ) {
|
|
if ( false ) {
|
|
// nothing
|
|
} else if ( nextarg == "help" ) {
|
|
std::ostringstream drivers;
|
|
drivers << " Available drivers:" << std::endl;
|
|
drivers << " " << "default" << std::endl;
|
|
#if defined( MPT_WITH_PULSEAUDIO )
|
|
drivers << " " << "pulseaudio" << std::endl;
|
|
#endif
|
|
#if defined( MPT_WITH_SDL2 )
|
|
drivers << " " << "sdl2" << std::endl;
|
|
#endif
|
|
#if defined( MPT_WITH_PORTAUDIO )
|
|
drivers << " " << "portaudio" << std::endl;
|
|
#endif
|
|
#if defined( WIN32 )
|
|
drivers << " " << "waveout" << std::endl;
|
|
#endif
|
|
#if defined( MPT_WITH_ALLEGRO42 )
|
|
drivers << " " << "allegro42" << std::endl;
|
|
#endif
|
|
throw show_help_exception( drivers.str() );
|
|
} else if ( nextarg == "default" ) {
|
|
flags.driver = "";
|
|
} else {
|
|
flags.driver = nextarg;
|
|
}
|
|
++i;
|
|
} else if ( arg == "--device" && nextarg != "" ) {
|
|
if ( false ) {
|
|
// nothing
|
|
} else if ( nextarg == "help" ) {
|
|
std::ostringstream devices;
|
|
devices << " Available devices:" << std::endl;
|
|
devices << " " << "default" << ": " << "default" << std::endl;
|
|
#if defined( MPT_WITH_PULSEAUDIO )
|
|
devices << show_pulseaudio_devices( log );
|
|
#endif
|
|
#if defined( MPT_WITH_SDL2 )
|
|
devices << show_sdl2_devices( log );
|
|
#endif
|
|
#if defined( MPT_WITH_PORTAUDIO )
|
|
devices << show_portaudio_devices( log );
|
|
#endif
|
|
#if defined( WIN32 )
|
|
devices << show_waveout_devices( log );
|
|
#endif
|
|
#if defined( MPT_WITH_ALLEGRO42 )
|
|
devices << show_allegro42_devices( log );
|
|
#endif
|
|
throw show_help_exception( devices.str() );
|
|
} else if ( nextarg == "default" ) {
|
|
flags.device = "";
|
|
} else {
|
|
flags.device = nextarg;
|
|
}
|
|
++i;
|
|
} else if ( arg == "--buffer" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.buffer;
|
|
++i;
|
|
} else if ( arg == "--period" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.period;
|
|
++i;
|
|
} else if ( arg == "--update" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.ui_redraw_interval;
|
|
++i;
|
|
} else if ( arg == "--stdout" ) {
|
|
flags.use_stdout = true;
|
|
} else if ( ( arg == "-o" || arg == "--output" ) && nextarg != "" ) {
|
|
flags.output_filename = nextarg;
|
|
++i;
|
|
} else if ( arg == "--force" ) {
|
|
flags.force_overwrite = true;
|
|
} else if ( arg == "--output-type" && nextarg != "" ) {
|
|
flags.output_extension = nextarg;
|
|
++i;
|
|
} else if ( arg == "--samplerate" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.samplerate;
|
|
++i;
|
|
} else if ( arg == "--channels" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.channels;
|
|
++i;
|
|
} else if ( arg == "--float" ) {
|
|
flags.use_float = true;
|
|
} else if ( arg == "--no-float" ) {
|
|
flags.use_float = false;
|
|
} else if ( arg == "--gain" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
double gain = 0.0;
|
|
istr >> gain;
|
|
flags.gain = static_cast<std::int32_t>( gain * 100.0 );
|
|
++i;
|
|
} else if ( arg == "--stereo" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.separation;
|
|
++i;
|
|
} else if ( arg == "--filter" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.filtertaps;
|
|
++i;
|
|
} else if ( arg == "--ramping" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.ramping;
|
|
++i;
|
|
} else if ( arg == "--tempo" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
double tmp = 1.0;
|
|
istr >> tmp;
|
|
flags.tempo = double_to_tempo_flag( tmp );
|
|
++i;
|
|
} else if ( arg == "--pitch" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
double tmp = 1.0;
|
|
istr >> tmp;
|
|
flags.pitch = double_to_pitch_flag( tmp );
|
|
++i;
|
|
} else if ( arg == "--dither" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.dither;
|
|
++i;
|
|
} else if ( arg == "--playlist" && nextarg != "" ) {
|
|
parse_playlist( flags, nextarg, log );
|
|
++i;
|
|
} else if ( arg == "--randomize" ) {
|
|
flags.randomize = true;
|
|
} else if ( arg == "--no-randomize" ) {
|
|
flags.randomize = false;
|
|
} else if ( arg == "--shuffle" ) {
|
|
flags.shuffle = true;
|
|
} else if ( arg == "--no-shuffle" ) {
|
|
flags.shuffle = false;
|
|
} else if ( arg == "--restart" ) {
|
|
flags.restart = true;
|
|
} else if ( arg == "--no-restart" ) {
|
|
flags.restart = false;
|
|
} else if ( arg == "--subsong" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.subsong;
|
|
++i;
|
|
} else if ( arg == "--repeat" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.repeatcount;
|
|
++i;
|
|
} else if ( arg == "--ctl" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
std::string ctl_c_v;
|
|
istr >> ctl_c_v;
|
|
if ( ctl_c_v.find( "=" ) == std::string::npos ) {
|
|
throw args_error_exception();
|
|
}
|
|
std::string ctl = ctl_c_v.substr( 0, ctl_c_v.find( "=" ) );
|
|
std::string val = ctl_c_v.substr( ctl_c_v.find( "=" ) + std::string("=").length(), std::string::npos );
|
|
if ( ctl.empty() ) {
|
|
throw args_error_exception();
|
|
}
|
|
flags.ctls[ ctl ] = val;
|
|
++i;
|
|
} else if ( arg == "--seek" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.seek_target;
|
|
++i;
|
|
} else if ( arg == "--end-time" && nextarg != "" ) {
|
|
std::istringstream istr( nextarg );
|
|
istr >> flags.end_time;
|
|
++i;
|
|
} else if ( arg.size() > 0 && arg.substr( 0, 1 ) == "-" ) {
|
|
throw args_error_exception();
|
|
}
|
|
}
|
|
}
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
#if defined(WIN32)
|
|
|
|
class FD_utf8_raii {
|
|
private:
|
|
FILE * file;
|
|
int old_mode;
|
|
public:
|
|
FD_utf8_raii( FILE * file, bool set_utf8 )
|
|
: file(file)
|
|
, old_mode(-1)
|
|
{
|
|
if ( set_utf8 ) {
|
|
fflush( file );
|
|
#if defined(UNICODE)
|
|
old_mode = _setmode( _fileno( file ), _O_U8TEXT );
|
|
#else
|
|
old_mode = _setmode( _fileno( file ), _O_TEXT );
|
|
#endif
|
|
if ( old_mode == -1 ) {
|
|
throw exception( "failed to set TEXT mode on file descriptor" );
|
|
}
|
|
}
|
|
}
|
|
~FD_utf8_raii()
|
|
{
|
|
if ( old_mode != -1 ) {
|
|
fflush( file );
|
|
old_mode = _setmode( _fileno( file ), old_mode );
|
|
}
|
|
}
|
|
};
|
|
|
|
class FD_binary_raii {
|
|
private:
|
|
FILE * file;
|
|
int old_mode;
|
|
public:
|
|
FD_binary_raii( FILE * file, bool set_binary )
|
|
: file(file)
|
|
, old_mode(-1)
|
|
{
|
|
if ( set_binary ) {
|
|
fflush( file );
|
|
old_mode = _setmode( _fileno( file ), _O_BINARY );
|
|
if ( old_mode == -1 ) {
|
|
throw exception( "failed to set binary mode on file descriptor" );
|
|
}
|
|
}
|
|
}
|
|
~FD_binary_raii()
|
|
{
|
|
if ( old_mode != -1 ) {
|
|
fflush( file );
|
|
old_mode = _setmode( _fileno( file ), old_mode );
|
|
}
|
|
}
|
|
};
|
|
|
|
#endif
|
|
|
|
#if defined(WIN32) && defined(UNICODE)
|
|
static int wmain( int wargc, wchar_t * wargv [] ) {
|
|
#else
|
|
static int main( int argc, char * argv [] ) {
|
|
#endif
|
|
std::vector<std::string> args;
|
|
#if defined(WIN32) && defined(UNICODE)
|
|
for ( int arg = 0; arg < wargc; ++arg ) {
|
|
args.push_back( mpt::transcode<std::string>( mpt::common_encoding::utf8, wargv[arg] ) );
|
|
}
|
|
#else
|
|
args = std::vector<std::string>( argv, argv + argc );
|
|
#endif
|
|
|
|
#if defined(WIN32)
|
|
FD_utf8_raii stdin_utf8_guard( stdin, true );
|
|
FD_utf8_raii stdout_utf8_guard( stdout, true );
|
|
FD_utf8_raii stderr_utf8_guard( stderr, true );
|
|
#endif
|
|
textout_dummy dummy_log;
|
|
#if defined(WIN32)
|
|
#if defined(UNICODE)
|
|
textout_ostream_console std_out( std::wcout, STD_OUTPUT_HANDLE );
|
|
textout_ostream_console std_err( std::wclog, STD_ERROR_HANDLE );
|
|
#else
|
|
textout_ostream_console std_out( std::cout, STD_OUTPUT_HANDLE );
|
|
textout_ostream_console std_err( std::clog, STD_ERROR_HANDLE );
|
|
#endif
|
|
#else
|
|
textout_ostream std_out( std::cout );
|
|
textout_ostream std_err( std::clog );
|
|
#endif
|
|
|
|
commandlineflags flags;
|
|
|
|
try {
|
|
|
|
flags = parse_openmpt123( args, std::cerr );
|
|
|
|
flags.check_and_sanitize();
|
|
|
|
} catch ( args_error_exception & ) {
|
|
show_help( std_out );
|
|
return 1;
|
|
} catch ( show_man_help_exception & ) {
|
|
show_help( std_out, false, true, true );
|
|
return 0;
|
|
} catch ( show_man_version_exception & ) {
|
|
show_man_version( std_out );
|
|
return 0;
|
|
} catch ( show_help_exception & e ) {
|
|
show_help( std_out, true, e.longhelp, false, e.message );
|
|
if ( flags.verbose ) {
|
|
show_credits( std_out );
|
|
}
|
|
return 0;
|
|
} catch ( show_help_keyboard_exception & ) {
|
|
show_help_keyboard( std_out );
|
|
return 0;
|
|
} catch ( show_long_version_number_exception & ) {
|
|
show_long_version( std_out );
|
|
return 0;
|
|
} catch ( show_version_number_exception & ) {
|
|
show_version( std_out );
|
|
return 0;
|
|
} catch ( show_short_version_number_exception & ) {
|
|
show_short_version( std_out );
|
|
return 0;
|
|
} catch ( show_credits_exception & ) {
|
|
show_credits( std_out );
|
|
return 0;
|
|
} catch ( show_license_exception & ) {
|
|
show_license( std_out );
|
|
return 0;
|
|
} catch ( silent_exit_exception & ) {
|
|
return 0;
|
|
} catch ( std::exception & e ) {
|
|
std_err << "error: " << e.what() << std::endl;
|
|
std_err.writeout();
|
|
return 1;
|
|
} catch ( ... ) {
|
|
std_err << "unknown error" << std::endl;
|
|
std_err.writeout();
|
|
return 1;
|
|
}
|
|
|
|
try {
|
|
|
|
bool stdin_can_ui = true;
|
|
for ( const auto & filename : flags.filenames ) {
|
|
if ( filename == "-" ) {
|
|
stdin_can_ui = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool stdout_can_ui = true;
|
|
if ( flags.use_stdout ) {
|
|
stdout_can_ui = false;
|
|
}
|
|
|
|
// set stdin binary
|
|
#if defined(WIN32)
|
|
FD_binary_raii stdin_guard( stdin, !stdin_can_ui );
|
|
#endif
|
|
|
|
// set stdout binary
|
|
#if defined(WIN32)
|
|
FD_binary_raii stdout_guard( stdout, !stdout_can_ui );
|
|
#endif
|
|
|
|
// setup terminal
|
|
#if !defined(WIN32)
|
|
if ( stdin_can_ui ) {
|
|
if ( flags.mode == Mode::UI ) {
|
|
set_input_mode();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
textout & log = flags.quiet ? static_cast<textout&>( dummy_log ) : static_cast<textout&>( stdout_can_ui ? std_out : std_err );
|
|
|
|
show_info( log, flags.verbose );
|
|
|
|
if ( !flags.warnings.empty() ) {
|
|
log << flags.warnings << std::endl;
|
|
}
|
|
|
|
if ( flags.verbose ) {
|
|
log << flags;
|
|
}
|
|
|
|
log.writeout();
|
|
|
|
std::default_random_engine prng;
|
|
try {
|
|
std::random_device rd;
|
|
std::seed_seq seq{ rd(), static_cast<unsigned int>( std::time( NULL ) ) };
|
|
prng = std::default_random_engine{ seq };
|
|
} catch ( const std::exception & ) {
|
|
std::seed_seq seq{ static_cast<unsigned int>( std::time( NULL ) ) };
|
|
prng = std::default_random_engine{ seq };
|
|
}
|
|
std::srand( std::uniform_int_distribution<unsigned int>()( prng ) );
|
|
|
|
switch ( flags.mode ) {
|
|
case Mode::Probe: {
|
|
for ( const auto & filename : flags.filenames ) {
|
|
probe_file( flags, filename, log );
|
|
flags.playlist_index++;
|
|
}
|
|
} break;
|
|
case Mode::Info: {
|
|
void_audio_stream dummy;
|
|
render_files( flags, log, dummy, prng );
|
|
} break;
|
|
case Mode::UI:
|
|
case Mode::Batch: {
|
|
if ( flags.use_stdout ) {
|
|
flags.apply_default_buffer_sizes();
|
|
stdout_stream_raii stdout_audio_stream;
|
|
render_files( flags, log, stdout_audio_stream, prng );
|
|
} else if ( !flags.output_filename.empty() ) {
|
|
flags.apply_default_buffer_sizes();
|
|
file_audio_stream_raii file_audio_stream( flags, flags.output_filename, log );
|
|
render_files( flags, log, file_audio_stream, prng );
|
|
#if defined( MPT_WITH_PULSEAUDIO )
|
|
} else if ( flags.driver == "pulseaudio" || flags.driver.empty() ) {
|
|
pulseaudio_stream_raii pulseaudio_stream( flags, log );
|
|
render_files( flags, log, pulseaudio_stream, prng );
|
|
#endif
|
|
#if defined( MPT_WITH_SDL2 )
|
|
} else if ( flags.driver == "sdl2" || flags.driver.empty() ) {
|
|
sdl2_stream_raii sdl2_stream( flags, log );
|
|
render_files( flags, log, sdl2_stream, prng );
|
|
#endif
|
|
#if defined( MPT_WITH_PORTAUDIO )
|
|
} else if ( flags.driver == "portaudio" || flags.driver.empty() ) {
|
|
portaudio_stream_raii portaudio_stream( flags, log );
|
|
render_files( flags, log, portaudio_stream, prng );
|
|
#endif
|
|
#if defined( WIN32 )
|
|
} else if ( flags.driver == "waveout" || flags.driver.empty() ) {
|
|
waveout_stream_raii waveout_stream( flags );
|
|
render_files( flags, log, waveout_stream, prng );
|
|
#endif
|
|
#if defined( MPT_WITH_ALLEGRO42 )
|
|
} else if ( flags.driver == "allegro42" || flags.driver.empty() ) {
|
|
allegro42_stream_raii allegro42_stream( flags, log );
|
|
render_files( flags, log, allegro42_stream, prng );
|
|
#endif
|
|
} else {
|
|
if ( flags.driver.empty() ) {
|
|
throw exception( "openmpt123 is compiled without any audio driver" );
|
|
} else {
|
|
throw exception( "audio driver '" + flags.driver + "' not found" );
|
|
}
|
|
}
|
|
} break;
|
|
case Mode::Render: {
|
|
for ( const auto & filename : flags.filenames ) {
|
|
flags.apply_default_buffer_sizes();
|
|
file_audio_stream_raii file_audio_stream( flags, filename + std::string(".") + flags.output_extension, log );
|
|
render_file( flags, filename, log, file_audio_stream );
|
|
flags.playlist_index++;
|
|
}
|
|
} break;
|
|
case Mode::None:
|
|
break;
|
|
}
|
|
|
|
} catch ( args_error_exception & ) {
|
|
show_help( std_out );
|
|
return 1;
|
|
#ifdef MPT_WITH_ALLEGRO42
|
|
} catch ( allegro42_exception & e ) {
|
|
std_err << "Allegro-4.2 error: " << e.what() << std::endl;
|
|
std_err.writeout();
|
|
return 1;
|
|
#endif
|
|
#ifdef MPT_WITH_PULSEAUDIO
|
|
} catch ( pulseaudio_exception & e ) {
|
|
std_err << "PulseAudio error: " << e.what() << std::endl;
|
|
std_err.writeout();
|
|
return 1;
|
|
#endif
|
|
#ifdef MPT_WITH_PORTAUDIO
|
|
} catch ( portaudio_exception & e ) {
|
|
std_err << "PortAudio error: " << e.what() << std::endl;
|
|
std_err.writeout();
|
|
return 1;
|
|
#endif
|
|
#ifdef MPT_WITH_SDL2
|
|
} catch ( sdl2_exception & e ) {
|
|
std_err << "SDL2 error: " << e.what() << std::endl;
|
|
std_err.writeout();
|
|
return 1;
|
|
#endif
|
|
} catch ( silent_exit_exception & ) {
|
|
return 0;
|
|
} catch ( std::exception & e ) {
|
|
std_err << "error: " << e.what() << std::endl;
|
|
std_err.writeout();
|
|
return 1;
|
|
} catch ( ... ) {
|
|
std_err << "unknown error" << std::endl;
|
|
std_err.writeout();
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
} // namespace openmpt123
|
|
|
|
#if defined(WIN32) && defined(UNICODE)
|
|
#if defined(__GNUC__) || (defined(__clang__) && !defined(_MSC_VER))
|
|
// mingw64 does only default to special C linkage for "main", but not for "wmain".
|
|
extern "C" int wmain( int wargc, wchar_t * wargv [] );
|
|
extern "C"
|
|
#endif
|
|
int wmain( int wargc, wchar_t * wargv [] ) {
|
|
return openmpt123::wmain( wargc, wargv );
|
|
}
|
|
#else
|
|
int main( int argc, char * argv [] ) {
|
|
return openmpt123::main( argc, argv );
|
|
}
|
|
#endif
|