Initial community commit
This commit is contained in:
Jef
parent
537bcbc862
commit
fc06254474
16440 changed files with 4239995 additions and 2 deletions
169
Src/external_dependencies/openmpt-trunk/examples/.clang-format
Normal file
169
Src/external_dependencies/openmpt-trunk/examples/.clang-format
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
# clang-format 14
|
||||
|
||||
Language: Cpp
|
||||
Standard: c++20
|
||||
|
||||
AccessModifierOffset: -2 #?
|
||||
AlignAfterOpenBracket: AlwaysBreak
|
||||
AlignArrayOfStructures: Left
|
||||
AlignConsecutiveAssignments: false
|
||||
AlignConsecutiveBitFields: false
|
||||
AlignConsecutiveDeclarations: false
|
||||
AlignConsecutiveMacros: true
|
||||
AlignEscapedNewlines: DontAlign
|
||||
AlignOperands: AlignAfterOperator
|
||||
AlignTrailingComments: true
|
||||
AllowAllArgumentsOnNextLine: true
|
||||
AllowAllConstructorInitializersOnNextLine: true
|
||||
AllowAllParametersOfDeclarationOnNextLine: true
|
||||
AllowShortBlocksOnASingleLine: Never
|
||||
AllowShortCaseLabelsOnASingleLine: false
|
||||
AllowShortEnumsOnASingleLine: false
|
||||
AllowShortFunctionsOnASingleLine: Empty
|
||||
AllowShortIfStatementsOnASingleLine: false
|
||||
AllowShortLambdasOnASingleLine: Inline
|
||||
AllowShortLoopsOnASingleLine: false
|
||||
AlwaysBreakAfterReturnType: None
|
||||
AlwaysBreakBeforeMultilineStrings: true
|
||||
AlwaysBreakTemplateDeclarations: Yes
|
||||
AttributeMacros: []
|
||||
BinPackArguments: true
|
||||
BinPackParameters: false
|
||||
BitFieldColonSpacing: Both
|
||||
BraceWrapping:
|
||||
AfterCaseLabel: true
|
||||
AfterClass: false
|
||||
AfterControlStatement: MultiLine
|
||||
AfterEnum: false
|
||||
AfterFunction: false
|
||||
AfterNamespace: false
|
||||
#AfterObjCDeclaration
|
||||
AfterStruct: false
|
||||
AfterUnion: false
|
||||
AfterExternBlock: false
|
||||
BeforeCatch: false
|
||||
BeforeElse: false
|
||||
BeforeLambdaBody: true
|
||||
BeforeWhile: false
|
||||
IndentBraces: false
|
||||
SplitEmptyFunction: true
|
||||
SplitEmptyRecord: false
|
||||
SplitEmptyNamespace: true
|
||||
#BreakAfterJavaFieldAnnotations
|
||||
BreakBeforeBinaryOperators: NonAssignment
|
||||
BreakBeforeBraces: Custom
|
||||
BreakBeforeConceptDeclarations: true
|
||||
BreakBeforeTernaryOperators: true
|
||||
BreakConstructorInitializers: BeforeComma
|
||||
BreakInheritanceList: BeforeComma
|
||||
BreakStringLiterals: false
|
||||
ColumnLimit: 0
|
||||
CommentPragmas: '' #?
|
||||
CompactNamespaces: false
|
||||
ConstructorInitializerAllOnOneLineOrOnePerLine: true
|
||||
ConstructorInitializerIndentWidth: 2 #?
|
||||
ContinuationIndentWidth: 2 #?
|
||||
Cpp11BracedListStyle: true
|
||||
DeriveLineEnding: true
|
||||
DerivePointerAlignment: false
|
||||
EmptyLineAfterAccessModifier: Leave
|
||||
EmptyLineBeforeAccessModifier: Leave
|
||||
FixNamespaceComments: true
|
||||
ForEachMacros: []
|
||||
IfMacros: ['MPT_MAYBE_CONSTANT_IF']
|
||||
IncludeBlocks: Preserve
|
||||
IncludeCategories: [] #?
|
||||
IncludeIsMainRegex: '' #?
|
||||
IncludeIsMainSourceRegex: '' #?
|
||||
IndentAccessModifiers: false
|
||||
IndentCaseBlocks: true
|
||||
IndentCaseLabels: true
|
||||
IndentExternBlock: NoIndent
|
||||
IndentGotoLabels: false
|
||||
IndentPPDirectives: None
|
||||
#IndentRequiresClause: true
|
||||
#BeforeHash
|
||||
IndentWidth: 2
|
||||
IndentWrappedFunctionNames: true
|
||||
InsertTrailingCommas: None
|
||||
#JavaImportGroups
|
||||
#JavaScriptQuotes
|
||||
#JavaScriptWrapImports
|
||||
KeepEmptyLinesAtTheStartOfBlocks: true
|
||||
LambdaBodyIndentation: OuterScope
|
||||
MacroBlockBegin: '' #?
|
||||
MacroBlockEnd: '' #?
|
||||
MaxEmptyLinesToKeep: 3
|
||||
NamespaceIndentation: None
|
||||
NamespaceMacros: [] #?
|
||||
#ObjCBinPackProtocolList
|
||||
#ObjCBlockIndentWidth
|
||||
#ObjCBreakBeforeNestedBlockParam
|
||||
#ObjCSpaceAfterProperty
|
||||
#ObjCSpaceBeforeProtocolList
|
||||
PackConstructorInitializers: Never
|
||||
#PenaltyBreakAssignment
|
||||
#PenaltyBreakBeforeFirstCallParameter
|
||||
#PenaltyBreakComment
|
||||
#PenaltyBreakFirstLessLess
|
||||
#PenaltyBreakOpenParenthesis
|
||||
#PenaltyBreakString
|
||||
#PenaltyBreakTemplateDeclaration
|
||||
#PenaltyExcessCharacter
|
||||
#PenaltyIndentedWhitespace
|
||||
#PenaltyReturnTypeOnItsOwnLine
|
||||
PointerAlignment: Middle
|
||||
PPIndentWidth: -1
|
||||
#RawStringFormats
|
||||
QualifierAlignment: Leave
|
||||
#QualifierOrder: ['static', 'inline', 'constexpr', 'volatile', 'const', 'restrict', 'type']
|
||||
ReferenceAlignment: Pointer
|
||||
ReflowComments: false
|
||||
RemoveBracesLLVM: false
|
||||
SeparateDefinitionBlocks: Leave
|
||||
ShortNamespaceLines: 1
|
||||
SortIncludes: false
|
||||
#SortJavaStaticImport
|
||||
SortUsingDeclarations: true
|
||||
SpaceAfterCStyleCast: false
|
||||
SpaceAfterLogicalNot: false
|
||||
SpaceAfterTemplateKeyword: true
|
||||
SpaceAroundPointerQualifiers: Default
|
||||
SpaceBeforeAssignmentOperators: true
|
||||
SpaceBeforeCaseColon: false
|
||||
SpaceBeforeCpp11BracedList: false
|
||||
SpaceBeforeCtorInitializerColon: true
|
||||
SpaceBeforeInheritanceColon: true
|
||||
SpaceBeforeParens: ControlStatements
|
||||
SpaceBeforeParensOptions:
|
||||
AfterControlStatements: true
|
||||
AfterForeachMacros: true
|
||||
AfterFunctionDeclarationName: false
|
||||
AfterFunctionDefinitionName: false
|
||||
AfterIfMacros: true
|
||||
AfterOverloadedOperator: false
|
||||
#AfterRequiresInClause: false
|
||||
#AfterRequiresInExpression: false
|
||||
BeforeNonEmptyParentheses: false
|
||||
SpaceBeforeRangeBasedForLoopColon: true
|
||||
SpaceBeforeSquareBrackets: false
|
||||
SpaceInEmptyBlock: true
|
||||
SpaceInEmptyParentheses: false
|
||||
SpacesBeforeTrailingComments: 2
|
||||
SpacesInAngles: false
|
||||
SpacesInCStyleCastParentheses: false
|
||||
SpacesInConditionalStatement: true
|
||||
SpacesInContainerLiterals: true
|
||||
SpacesInLineCommentPrefix:
|
||||
Minimum: 1
|
||||
Maximum: -1
|
||||
SpacesInParentheses: true
|
||||
SpacesInSquareBrackets: false
|
||||
StatementAttributeLikeMacros: []
|
||||
StatementMacros: [ 'MPT_WARNING', 'MPT_TEST_GROUP_INLINE_IDENTIFIER', 'MPT_TEST_GROUP_INLINE', 'MPT_TEST_GROUP_STATIC' ] #?
|
||||
TabWidth: 2
|
||||
TypenameMacros: [] #?
|
||||
UseCRLF: false
|
||||
UseTab: ForContinuationAndIndentation
|
||||
WhitespaceSensitiveMacros:
|
||||
- MPT_PP_STRINGIFY
|
||||
|
|
@ -0,0 +1,213 @@
|
|||
/*
|
||||
* libopenmpt_example_c.c
|
||||
* ----------------------
|
||||
* Purpose: libopenmpt C API example
|
||||
* Notes : PortAudio is used for sound output.
|
||||
* Authors: OpenMPT Devs
|
||||
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Usage: libopenmpt_example_c SOMEMODULE
|
||||
*/
|
||||
|
||||
#include <memory.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <libopenmpt/libopenmpt.h>
|
||||
#include <libopenmpt/libopenmpt_stream_callbacks_file.h>
|
||||
|
||||
#include <portaudio.h>
|
||||
|
||||
#define BUFFERSIZE 480
|
||||
#define SAMPLERATE 48000
|
||||
|
||||
static int16_t left[BUFFERSIZE];
|
||||
static int16_t right[BUFFERSIZE];
|
||||
static int16_t * const buffers[2] = { left, right };
|
||||
static int16_t interleaved_buffer[BUFFERSIZE * 2];
|
||||
static int is_interleaved = 0;
|
||||
|
||||
static void libopenmpt_example_logfunc( const char * message, void * userdata ) {
|
||||
(void)userdata;
|
||||
if ( message ) {
|
||||
fprintf( stderr, "openmpt: %s\n", message );
|
||||
}
|
||||
}
|
||||
|
||||
static int libopenmpt_example_errfunc( int error, void * userdata ) {
|
||||
(void)userdata;
|
||||
(void)error;
|
||||
return OPENMPT_ERROR_FUNC_RESULT_DEFAULT & ~OPENMPT_ERROR_FUNC_RESULT_LOG;
|
||||
}
|
||||
|
||||
static void libopenmpt_example_print_error( const char * func_name, int mod_err, const char * mod_err_str ) {
|
||||
if ( !func_name ) {
|
||||
func_name = "unknown function";
|
||||
}
|
||||
if ( mod_err == OPENMPT_ERROR_OUT_OF_MEMORY ) {
|
||||
mod_err_str = openmpt_error_string( mod_err );
|
||||
if ( !mod_err_str ) {
|
||||
fprintf( stderr, "Error: %s\n", "OPENMPT_ERROR_OUT_OF_MEMORY" );
|
||||
} else {
|
||||
fprintf( stderr, "Error: %s\n", mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
} else {
|
||||
if ( !mod_err_str ) {
|
||||
mod_err_str = openmpt_error_string( mod_err );
|
||||
if ( !mod_err_str ) {
|
||||
fprintf( stderr, "Error: %s failed.\n", func_name );
|
||||
} else {
|
||||
fprintf( stderr, "Error: %s failed: %s\n", func_name, mod_err_str );
|
||||
}
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
fprintf( stderr, "Error: %s failed: %s\n", func_name, mod_err_str );
|
||||
}
|
||||
}
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
#if defined( __clang__ ) && !defined( _MSC_VER )
|
||||
int wmain( int argc, wchar_t * argv[] );
|
||||
#endif
|
||||
int wmain( int argc, wchar_t * argv[] ) {
|
||||
#else
|
||||
int main( int argc, char * argv[] ) {
|
||||
#endif
|
||||
|
||||
int result = 0;
|
||||
FILE * file = 0;
|
||||
openmpt_module * mod = 0;
|
||||
int mod_err = OPENMPT_ERROR_OK;
|
||||
const char * mod_err_str = NULL;
|
||||
size_t count = 0;
|
||||
PaError pa_error = paNoError;
|
||||
int pa_initialized = 0;
|
||||
PaStream * stream = 0;
|
||||
|
||||
if ( argc != 2 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
if ( wcslen( argv[1] ) == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
file = _wfopen( argv[1], L"rb" );
|
||||
#else
|
||||
if ( strlen( argv[1] ) == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
file = fopen( argv[1], "rb" );
|
||||
#endif
|
||||
if ( !file ) {
|
||||
fprintf( stderr, "Error: %s\n", "fopen() failed." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
mod = openmpt_module_create2( openmpt_stream_get_file_callbacks(), file, &libopenmpt_example_logfunc, NULL, &libopenmpt_example_errfunc, NULL, &mod_err, &mod_err_str, NULL );
|
||||
if ( !mod ) {
|
||||
libopenmpt_example_print_error( "openmpt_module_create2()", mod_err, mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
goto fail;
|
||||
}
|
||||
openmpt_module_set_error_func( mod, NULL, NULL );
|
||||
|
||||
pa_error = Pa_Initialize();
|
||||
if ( pa_error != paNoError ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_Initialize() failed." );
|
||||
goto fail;
|
||||
}
|
||||
pa_initialized = 1;
|
||||
|
||||
pa_error = Pa_OpenDefaultStream( &stream, 0, 2, paInt16 | paNonInterleaved, SAMPLERATE, paFramesPerBufferUnspecified, NULL, NULL );
|
||||
if ( pa_error == paSampleFormatNotSupported ) {
|
||||
is_interleaved = 1;
|
||||
pa_error = Pa_OpenDefaultStream( &stream, 0, 2, paInt16, SAMPLERATE, paFramesPerBufferUnspecified, NULL, NULL );
|
||||
}
|
||||
if ( pa_error != paNoError ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_OpenStream() failed." );
|
||||
goto fail;
|
||||
}
|
||||
if ( !stream ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_OpenStream() failed." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
pa_error = Pa_StartStream( stream );
|
||||
if ( pa_error != paNoError ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_StartStream() failed." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
while ( 1 ) {
|
||||
|
||||
openmpt_module_error_clear( mod );
|
||||
count = is_interleaved ? openmpt_module_read_interleaved_stereo( mod, SAMPLERATE, BUFFERSIZE, interleaved_buffer ) : openmpt_module_read_stereo( mod, SAMPLERATE, BUFFERSIZE, left, right );
|
||||
mod_err = openmpt_module_error_get_last( mod );
|
||||
mod_err_str = openmpt_module_error_get_last_message( mod );
|
||||
if ( mod_err != OPENMPT_ERROR_OK ) {
|
||||
libopenmpt_example_print_error( "openmpt_module_read_stereo()", mod_err, mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
if ( count == 0 ) {
|
||||
break;
|
||||
}
|
||||
|
||||
pa_error = is_interleaved ? Pa_WriteStream( stream, interleaved_buffer, (unsigned long)count ) : Pa_WriteStream( stream, buffers, (unsigned long)count );
|
||||
if ( pa_error == paOutputUnderflowed ) {
|
||||
pa_error = paNoError;
|
||||
}
|
||||
if ( pa_error != paNoError ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_WriteStream() failed." );
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
result = 0;
|
||||
|
||||
goto cleanup;
|
||||
|
||||
fail:
|
||||
|
||||
result = 1;
|
||||
|
||||
cleanup:
|
||||
|
||||
if ( stream ) {
|
||||
if ( Pa_IsStreamActive( stream ) == 1 ) {
|
||||
Pa_StopStream( stream );
|
||||
}
|
||||
Pa_CloseStream( stream );
|
||||
stream = 0;
|
||||
}
|
||||
|
||||
if ( pa_initialized ) {
|
||||
Pa_Terminate();
|
||||
pa_initialized = 0;
|
||||
(void)pa_initialized;
|
||||
}
|
||||
|
||||
if ( mod ) {
|
||||
openmpt_module_destroy( mod );
|
||||
mod = 0;
|
||||
}
|
||||
|
||||
if ( file ) {
|
||||
fclose( file );
|
||||
file = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -0,0 +1,303 @@
|
|||
/*
|
||||
* libopenmpt_example_c_mem.c
|
||||
* --------------------------
|
||||
* Purpose: libopenmpt C API example
|
||||
* Notes : PortAudio is used for sound output.
|
||||
* Authors: OpenMPT Devs
|
||||
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Usage: libopenmpt_example_c_mem SOMEMODULE
|
||||
*/
|
||||
|
||||
#include <memory.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <libopenmpt/libopenmpt.h>
|
||||
|
||||
#include <portaudio.h>
|
||||
|
||||
#define BUFFERSIZE 480
|
||||
#define SAMPLERATE 48000
|
||||
|
||||
static int16_t left[BUFFERSIZE];
|
||||
static int16_t right[BUFFERSIZE];
|
||||
static int16_t * const buffers[2] = { left, right };
|
||||
static int16_t interleaved_buffer[BUFFERSIZE * 2];
|
||||
static int is_interleaved = 0;
|
||||
|
||||
static void libopenmpt_example_logfunc( const char * message, void * userdata ) {
|
||||
(void)userdata;
|
||||
if ( message ) {
|
||||
fprintf( stderr, "openmpt: %s\n", message );
|
||||
}
|
||||
}
|
||||
|
||||
static int libopenmpt_example_errfunc( int error, void * userdata ) {
|
||||
(void)userdata;
|
||||
(void)error;
|
||||
return OPENMPT_ERROR_FUNC_RESULT_DEFAULT & ~OPENMPT_ERROR_FUNC_RESULT_LOG;
|
||||
}
|
||||
|
||||
static void libopenmpt_example_print_error( const char * func_name, int mod_err, const char * mod_err_str ) {
|
||||
if ( !func_name ) {
|
||||
func_name = "unknown function";
|
||||
}
|
||||
if ( mod_err == OPENMPT_ERROR_OUT_OF_MEMORY ) {
|
||||
mod_err_str = openmpt_error_string( mod_err );
|
||||
if ( !mod_err_str ) {
|
||||
fprintf( stderr, "Error: %s\n", "OPENMPT_ERROR_OUT_OF_MEMORY" );
|
||||
} else {
|
||||
fprintf( stderr, "Error: %s\n", mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
} else {
|
||||
if ( !mod_err_str ) {
|
||||
mod_err_str = openmpt_error_string( mod_err );
|
||||
if ( !mod_err_str ) {
|
||||
fprintf( stderr, "Error: %s failed.\n", func_name );
|
||||
} else {
|
||||
fprintf( stderr, "Error: %s failed: %s\n", func_name, mod_err_str );
|
||||
}
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
fprintf( stderr, "Error: %s failed: %s\n", func_name, mod_err_str );
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct blob_t {
|
||||
size_t size;
|
||||
void * data;
|
||||
} blob_t;
|
||||
|
||||
static void free_blob( blob_t * blob ) {
|
||||
if ( blob ) {
|
||||
if ( blob->data ) {
|
||||
free( blob->data );
|
||||
blob->data = 0;
|
||||
}
|
||||
blob->size = 0;
|
||||
free( blob );
|
||||
}
|
||||
}
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
static blob_t * load_file( const wchar_t * filename ) {
|
||||
#else
|
||||
static blob_t * load_file( const char * filename ) {
|
||||
#endif
|
||||
blob_t * result = 0;
|
||||
|
||||
blob_t * blob = 0;
|
||||
FILE * file = 0;
|
||||
long tell_result = 0;
|
||||
|
||||
blob = malloc( sizeof( blob_t ) );
|
||||
if ( !blob ) {
|
||||
goto fail;
|
||||
}
|
||||
memset( blob, 0, sizeof( blob_t ) );
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
file = _wfopen( filename, L"rb" );
|
||||
#else
|
||||
file = fopen( filename, "rb" );
|
||||
#endif
|
||||
if ( !file ) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if ( fseek( file, 0, SEEK_END ) != 0 ) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
tell_result = ftell( file );
|
||||
if ( tell_result < 0 ) {
|
||||
goto fail;
|
||||
}
|
||||
if ( (unsigned long)(size_t)(unsigned long)tell_result != (unsigned long)tell_result ) {
|
||||
goto fail;
|
||||
}
|
||||
blob->size = (size_t)tell_result;
|
||||
|
||||
if ( fseek( file, 0, SEEK_SET ) != 0 ) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
blob->data = malloc( blob->size );
|
||||
if ( !blob->data ) {
|
||||
goto fail;
|
||||
}
|
||||
memset( blob->data, 0, blob->size );
|
||||
|
||||
if ( fread( blob->data, 1, blob->size, file ) != blob->size ) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
result = blob;
|
||||
blob = 0;
|
||||
goto cleanup;
|
||||
|
||||
fail:
|
||||
|
||||
result = 0;
|
||||
|
||||
cleanup:
|
||||
|
||||
if ( blob ) {
|
||||
free_blob( blob );
|
||||
blob = 0;
|
||||
}
|
||||
|
||||
if ( file ) {
|
||||
fclose( file );
|
||||
file = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
#if defined( __clang__ ) && !defined( _MSC_VER )
|
||||
int wmain( int argc, wchar_t * argv[] );
|
||||
#endif
|
||||
int wmain( int argc, wchar_t * argv[] ) {
|
||||
#else
|
||||
int main( int argc, char * argv[] ) {
|
||||
#endif
|
||||
|
||||
int result = 0;
|
||||
blob_t * blob = 0;
|
||||
openmpt_module * mod = 0;
|
||||
int mod_err = OPENMPT_ERROR_OK;
|
||||
const char * mod_err_str = NULL;
|
||||
size_t count = 0;
|
||||
PaError pa_error = paNoError;
|
||||
int pa_initialized = 0;
|
||||
PaStream * stream = 0;
|
||||
|
||||
if ( argc != 2 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_mem SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
if ( wcslen( argv[1] ) == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_mem SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
#else
|
||||
if ( strlen( argv[1] ) == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_mem SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
#endif
|
||||
blob = load_file( argv[1] );
|
||||
if ( !blob ) {
|
||||
fprintf( stderr, "Error: %s\n", "load_file() failed." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
mod = openmpt_module_create_from_memory2( blob->data, blob->size, &libopenmpt_example_logfunc, NULL, &libopenmpt_example_errfunc, NULL, &mod_err, &mod_err_str, NULL );
|
||||
if ( !mod ) {
|
||||
libopenmpt_example_print_error( "openmpt_module_create_from_memory2()", mod_err, mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
pa_error = Pa_Initialize();
|
||||
if ( pa_error != paNoError ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_Initialize() failed." );
|
||||
goto fail;
|
||||
}
|
||||
pa_initialized = 1;
|
||||
|
||||
is_interleaved = 0;
|
||||
pa_error = Pa_OpenDefaultStream( &stream, 0, 2, paInt16 | paNonInterleaved, SAMPLERATE, paFramesPerBufferUnspecified, NULL, NULL );
|
||||
if ( pa_error == paSampleFormatNotSupported ) {
|
||||
is_interleaved = 1;
|
||||
pa_error = Pa_OpenDefaultStream( &stream, 0, 2, paInt16, SAMPLERATE, paFramesPerBufferUnspecified, NULL, NULL );
|
||||
}
|
||||
if ( pa_error != paNoError ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_OpenStream() failed." );
|
||||
goto fail;
|
||||
}
|
||||
if ( !stream ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_OpenStream() failed." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
pa_error = Pa_StartStream( stream );
|
||||
if ( pa_error != paNoError ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_StartStream() failed." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
while ( 1 ) {
|
||||
|
||||
openmpt_module_error_clear( mod );
|
||||
count = is_interleaved ? openmpt_module_read_interleaved_stereo( mod, SAMPLERATE, BUFFERSIZE, interleaved_buffer ) : openmpt_module_read_stereo( mod, SAMPLERATE, BUFFERSIZE, left, right );
|
||||
mod_err = openmpt_module_error_get_last( mod );
|
||||
mod_err_str = openmpt_module_error_get_last_message( mod );
|
||||
if ( mod_err != OPENMPT_ERROR_OK ) {
|
||||
libopenmpt_example_print_error( "openmpt_module_read_stereo()", mod_err, mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
if ( count == 0 ) {
|
||||
break;
|
||||
}
|
||||
|
||||
pa_error = is_interleaved ? Pa_WriteStream( stream, interleaved_buffer, (unsigned long)count ) : Pa_WriteStream( stream, buffers, (unsigned long)count );
|
||||
if ( pa_error == paOutputUnderflowed ) {
|
||||
pa_error = paNoError;
|
||||
}
|
||||
if ( pa_error != paNoError ) {
|
||||
fprintf( stderr, "Error: %s\n", "Pa_WriteStream() failed." );
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
result = 0;
|
||||
|
||||
goto cleanup;
|
||||
|
||||
fail:
|
||||
|
||||
result = 1;
|
||||
|
||||
cleanup:
|
||||
|
||||
if ( stream ) {
|
||||
if ( Pa_IsStreamActive( stream ) == 1 ) {
|
||||
Pa_StopStream( stream );
|
||||
}
|
||||
Pa_CloseStream( stream );
|
||||
stream = 0;
|
||||
}
|
||||
|
||||
if ( pa_initialized ) {
|
||||
Pa_Terminate();
|
||||
pa_initialized = 0;
|
||||
(void)pa_initialized;
|
||||
}
|
||||
|
||||
if ( mod ) {
|
||||
openmpt_module_destroy( mod );
|
||||
mod = 0;
|
||||
}
|
||||
|
||||
if ( blob ) {
|
||||
free_blob( blob );
|
||||
blob = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -0,0 +1,155 @@
|
|||
/*
|
||||
* libopenmpt_example_c_pipe.c
|
||||
* ---------------------------
|
||||
* Purpose: libopenmpt C API simple pipe example
|
||||
* Notes : This example writes raw 48000Hz / stereo / 16bit native endian PCM data to stdout.
|
||||
* Authors: OpenMPT Devs
|
||||
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Usage: cat SOMEMODULE | libopenmpt_example_c_pipe | aplay --file-type raw --format=dat
|
||||
*/
|
||||
|
||||
#include <memory.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <libopenmpt/libopenmpt.h>
|
||||
#include <libopenmpt/libopenmpt_stream_callbacks_fd.h>
|
||||
|
||||
#define BUFFERSIZE 480
|
||||
#define SAMPLERATE 48000
|
||||
|
||||
static void libopenmpt_example_logfunc( const char * message, void * userdata ) {
|
||||
(void)userdata;
|
||||
if ( message ) {
|
||||
fprintf( stderr, "openmpt: %s\n", message );
|
||||
}
|
||||
}
|
||||
|
||||
static int libopenmpt_example_errfunc( int error, void * userdata ) {
|
||||
(void)userdata;
|
||||
(void)error;
|
||||
return OPENMPT_ERROR_FUNC_RESULT_DEFAULT & ~OPENMPT_ERROR_FUNC_RESULT_LOG;
|
||||
}
|
||||
|
||||
static void libopenmpt_example_print_error( const char * func_name, int mod_err, const char * mod_err_str ) {
|
||||
if ( !func_name ) {
|
||||
func_name = "unknown function";
|
||||
}
|
||||
if ( mod_err == OPENMPT_ERROR_OUT_OF_MEMORY ) {
|
||||
mod_err_str = openmpt_error_string( mod_err );
|
||||
if ( !mod_err_str ) {
|
||||
fprintf( stderr, "Error: %s\n", "OPENMPT_ERROR_OUT_OF_MEMORY" );
|
||||
} else {
|
||||
fprintf( stderr, "Error: %s\n", mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
} else {
|
||||
if ( !mod_err_str ) {
|
||||
mod_err_str = openmpt_error_string( mod_err );
|
||||
if ( !mod_err_str ) {
|
||||
fprintf( stderr, "Error: %s failed.\n", func_name );
|
||||
} else {
|
||||
fprintf( stderr, "Error: %s failed: %s\n", func_name, mod_err_str );
|
||||
}
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
fprintf( stderr, "Error: %s failed: %s\n", func_name, mod_err_str );
|
||||
}
|
||||
}
|
||||
|
||||
static ssize_t xwrite( int fd, const void * buffer, size_t size ) {
|
||||
size_t written = 0;
|
||||
ssize_t retval = 0;
|
||||
while ( written < size ) {
|
||||
retval = write( fd, (const char *)buffer + written, size - written );
|
||||
if ( retval < 0 ) {
|
||||
if ( errno != EINTR ) {
|
||||
break;
|
||||
}
|
||||
retval = 0;
|
||||
}
|
||||
written += retval;
|
||||
}
|
||||
return written;
|
||||
}
|
||||
|
||||
static int16_t buffer[BUFFERSIZE * 2];
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
#if defined( __clang__ ) && !defined( _MSC_VER )
|
||||
int wmain( int argc, wchar_t * argv[] );
|
||||
#endif
|
||||
int wmain( int argc, wchar_t * argv[] ) {
|
||||
#else
|
||||
int main( int argc, char * argv[] ) {
|
||||
#endif
|
||||
|
||||
int result = 0;
|
||||
openmpt_module * mod = 0;
|
||||
int mod_err = OPENMPT_ERROR_OK;
|
||||
const char * mod_err_str = NULL;
|
||||
size_t count = 0;
|
||||
size_t written = 0;
|
||||
(void)argv;
|
||||
|
||||
if ( argc != 1 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_pipe' and connect stdin and stdout." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
mod = openmpt_module_create2( openmpt_stream_get_fd_callbacks(), (void *)(uintptr_t)STDIN_FILENO, &libopenmpt_example_logfunc, NULL, &libopenmpt_example_errfunc, NULL, &mod_err, &mod_err_str, NULL );
|
||||
if ( !mod ) {
|
||||
libopenmpt_example_print_error( "openmpt_module_create2()", mod_err, mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
while ( 1 ) {
|
||||
|
||||
openmpt_module_error_clear( mod );
|
||||
count = openmpt_module_read_interleaved_stereo( mod, SAMPLERATE, BUFFERSIZE, buffer );
|
||||
mod_err = openmpt_module_error_get_last( mod );
|
||||
mod_err_str = openmpt_module_error_get_last_message( mod );
|
||||
if ( mod_err != OPENMPT_ERROR_OK ) {
|
||||
libopenmpt_example_print_error( "openmpt_module_read_interleaved_stereo()", mod_err, mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
if ( count == 0 ) {
|
||||
break;
|
||||
}
|
||||
|
||||
written = xwrite( STDOUT_FILENO, buffer, count * 2 * sizeof( int16_t ) );
|
||||
if ( written == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "write() failed." );
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
result = 0;
|
||||
|
||||
goto cleanup;
|
||||
|
||||
fail:
|
||||
|
||||
result = 1;
|
||||
|
||||
cleanup:
|
||||
|
||||
if ( mod ) {
|
||||
openmpt_module_destroy( mod );
|
||||
mod = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -0,0 +1,183 @@
|
|||
/*
|
||||
* libopenmpt_example_c_probe.c
|
||||
* ----------------------------
|
||||
* Purpose: libopenmpt C API probing example
|
||||
* Notes : (currently none)
|
||||
* Authors: OpenMPT Devs
|
||||
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Usage: libopenmpt_example_c_probe SOMEMODULE ...
|
||||
* Returns 0 on successful probing for all files.
|
||||
* Returns 1 on failed probing for 1 or more files.
|
||||
* Returns 2 on error.
|
||||
*/
|
||||
|
||||
#define LIBOPENMPT_EXAMPLE_PROBE_RESULT_BINARY 1
|
||||
#define LIBOPENMPT_EXAMPLE_PROBE_RESULT_FLOAT 2
|
||||
|
||||
#define LIBOPENMPT_EXAMPLE_PROBE_RESULT LIBOPENMPT_EXAMPLE_PROBE_RESULT_BINARY
|
||||
|
||||
#include <memory.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <libopenmpt/libopenmpt.h>
|
||||
#include <libopenmpt/libopenmpt_stream_callbacks_file.h>
|
||||
|
||||
static void libopenmpt_example_logfunc( const char * message, void * userdata ) {
|
||||
(void)userdata;
|
||||
|
||||
if ( message ) {
|
||||
fprintf( stderr, "%s\n", message );
|
||||
}
|
||||
}
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
static int probe_file( const wchar_t * filename ) {
|
||||
#else
|
||||
static int probe_file( const char * filename ) {
|
||||
#endif
|
||||
|
||||
int result = 0;
|
||||
int mod_err = OPENMPT_ERROR_OK;
|
||||
FILE * file = NULL;
|
||||
|
||||
#if ( LIBOPENMPT_EXAMPLE_PROBE_RESULT == LIBOPENMPT_EXAMPLE_PROBE_RESULT_BINARY )
|
||||
int result_binary = 0;
|
||||
int probe_file_header_result = OPENMPT_PROBE_FILE_HEADER_RESULT_FAILURE;
|
||||
const char * probe_file_header_result_str = NULL;
|
||||
#endif
|
||||
#if ( LIBOPENMPT_EXAMPLE_PROBE_RESULT == LIBOPENMPT_EXAMPLE_PROBE_RESULT_FLOAT )
|
||||
double probability = 0.0;
|
||||
#endif
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
if ( wcslen( filename ) == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_probe SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
#else
|
||||
if ( strlen( filename ) == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_probe SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
file = _wfopen( filename, L"rb" );
|
||||
#else
|
||||
file = fopen( filename, "rb" );
|
||||
#endif
|
||||
if ( !file ) {
|
||||
fprintf( stderr, "Error: %s\n", "fopen() failed." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
#if ( LIBOPENMPT_EXAMPLE_PROBE_RESULT == LIBOPENMPT_EXAMPLE_PROBE_RESULT_BINARY )
|
||||
probe_file_header_result = openmpt_probe_file_header_from_stream( OPENMPT_PROBE_FILE_HEADER_FLAGS_DEFAULT, openmpt_stream_get_file_callbacks(), file, &libopenmpt_example_logfunc, NULL, &openmpt_error_func_default, NULL, &mod_err, NULL );
|
||||
probe_file_header_result_str = NULL;
|
||||
switch ( probe_file_header_result ) {
|
||||
case OPENMPT_PROBE_FILE_HEADER_RESULT_SUCCESS:
|
||||
probe_file_header_result_str = "Success ";
|
||||
result_binary = 1;
|
||||
break;
|
||||
case OPENMPT_PROBE_FILE_HEADER_RESULT_FAILURE:
|
||||
probe_file_header_result_str = "Failure ";
|
||||
result_binary = 0;
|
||||
break;
|
||||
case OPENMPT_PROBE_FILE_HEADER_RESULT_WANTMOREDATA:
|
||||
probe_file_header_result_str = "WantMoreData";
|
||||
result_binary = 0;
|
||||
break;
|
||||
case OPENMPT_PROBE_FILE_HEADER_RESULT_ERROR:
|
||||
result_binary = 0;
|
||||
(void)result_binary;
|
||||
fprintf( stderr, "Error: %s\n", "openmpt_probe_file_header() failed." );
|
||||
goto fail;
|
||||
break;
|
||||
default:
|
||||
result_binary = 0;
|
||||
(void)result_binary;
|
||||
fprintf( stderr, "Error: %s\n", "openmpt_probe_file_header() failed." );
|
||||
goto fail;
|
||||
break;
|
||||
}
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
fprintf( stdout, "%s - %ls\n", probe_file_header_result_str, filename );
|
||||
#else
|
||||
fprintf( stdout, "%s - %s\n", probe_file_header_result_str, filename );
|
||||
#endif
|
||||
if ( result_binary ) {
|
||||
result = 0;
|
||||
} else {
|
||||
result = 1;
|
||||
}
|
||||
#elif ( LIBOPENMPT_EXAMPLE_PROBE_RESULT == LIBOPENMPT_EXAMPLE_PROBE_RESULT_FLOAT )
|
||||
probability = openmpt_could_open_probability2( openmpt_stream_get_file_callbacks(), file, 0.25, &libopenmpt_example_logfunc, NULL, &openmpt_error_func_default, NULL, &mod_err, NULL );
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
fprintf( stdout, "%s: %f - %ls\n", "Result", probability, filename );
|
||||
#else
|
||||
fprintf( stdout, "%s: %f - %s\n", "Result", probability, filename );
|
||||
#endif
|
||||
if ( probability >= 0.5 ) {
|
||||
result = 0;
|
||||
} else {
|
||||
result = 1;
|
||||
}
|
||||
#else
|
||||
#error "LIBOPENMPT_EXAMPLE_PROBE_RESULT is wrong"
|
||||
#endif
|
||||
|
||||
goto cleanup;
|
||||
|
||||
fail:
|
||||
|
||||
result = 2;
|
||||
|
||||
cleanup:
|
||||
|
||||
if ( file ) {
|
||||
fclose( file );
|
||||
file = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
#if defined( __clang__ ) && !defined( _MSC_VER )
|
||||
int wmain( int argc, wchar_t * argv[] );
|
||||
#endif
|
||||
int wmain( int argc, wchar_t * argv[] ) {
|
||||
#else
|
||||
int main( int argc, char * argv[] ) {
|
||||
#endif
|
||||
|
||||
int global_result = 0;
|
||||
|
||||
if ( argc <= 1 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_probe SOMEMODULE ...'." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
for ( int i = 1; i < argc; ++i ) {
|
||||
int result = probe_file( argv[i] );
|
||||
if ( result > global_result ) {
|
||||
global_result = result;
|
||||
}
|
||||
}
|
||||
|
||||
goto cleanup;
|
||||
|
||||
fail:
|
||||
|
||||
global_result = 2;
|
||||
|
||||
cleanup:
|
||||
|
||||
return global_result;
|
||||
}
|
||||
|
|
@ -0,0 +1,179 @@
|
|||
/*
|
||||
* libopenmpt_example_c_stdout.c
|
||||
* -----------------------------
|
||||
* Purpose: libopenmpt C API simple example
|
||||
* Notes : This example writes raw 48000Hz / stereo / 16bit native endian PCM data to stdout.
|
||||
* Authors: OpenMPT Devs
|
||||
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Usage: libopenmpt_example_c_stdout SOMEMODULE | aplay --file-type raw --format=dat
|
||||
*/
|
||||
|
||||
#include <memory.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <libopenmpt/libopenmpt.h>
|
||||
#include <libopenmpt/libopenmpt_stream_callbacks_file.h>
|
||||
|
||||
#define BUFFERSIZE 480
|
||||
#define SAMPLERATE 48000
|
||||
|
||||
static void libopenmpt_example_logfunc( const char * message, void * userdata ) {
|
||||
(void)userdata;
|
||||
if ( message ) {
|
||||
fprintf( stderr, "openmpt: %s\n", message );
|
||||
}
|
||||
}
|
||||
|
||||
static int libopenmpt_example_errfunc( int error, void * userdata ) {
|
||||
(void)userdata;
|
||||
(void)error;
|
||||
return OPENMPT_ERROR_FUNC_RESULT_DEFAULT & ~OPENMPT_ERROR_FUNC_RESULT_LOG;
|
||||
}
|
||||
|
||||
static void libopenmpt_example_print_error( const char * func_name, int mod_err, const char * mod_err_str ) {
|
||||
if ( !func_name ) {
|
||||
func_name = "unknown function";
|
||||
}
|
||||
if ( mod_err == OPENMPT_ERROR_OUT_OF_MEMORY ) {
|
||||
mod_err_str = openmpt_error_string( mod_err );
|
||||
if ( !mod_err_str ) {
|
||||
fprintf( stderr, "Error: %s\n", "OPENMPT_ERROR_OUT_OF_MEMORY" );
|
||||
} else {
|
||||
fprintf( stderr, "Error: %s\n", mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
} else {
|
||||
if ( !mod_err_str ) {
|
||||
mod_err_str = openmpt_error_string( mod_err );
|
||||
if ( !mod_err_str ) {
|
||||
fprintf( stderr, "Error: %s failed.\n", func_name );
|
||||
} else {
|
||||
fprintf( stderr, "Error: %s failed: %s\n", func_name, mod_err_str );
|
||||
}
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
fprintf( stderr, "Error: %s failed: %s\n", func_name, mod_err_str );
|
||||
}
|
||||
}
|
||||
|
||||
static ssize_t xwrite( int fd, const void * buffer, size_t size ) {
|
||||
size_t written = 0;
|
||||
ssize_t retval = 0;
|
||||
while ( written < size ) {
|
||||
retval = write( fd, (const char *)buffer + written, size - written );
|
||||
if ( retval < 0 ) {
|
||||
if ( errno != EINTR ) {
|
||||
break;
|
||||
}
|
||||
retval = 0;
|
||||
}
|
||||
written += retval;
|
||||
}
|
||||
return written;
|
||||
}
|
||||
|
||||
static int16_t buffer[BUFFERSIZE * 2];
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
#if defined( __clang__ ) && !defined( _MSC_VER )
|
||||
int wmain( int argc, wchar_t * argv[] );
|
||||
#endif
|
||||
int wmain( int argc, wchar_t * argv[] ) {
|
||||
#else
|
||||
int main( int argc, char * argv[] ) {
|
||||
#endif
|
||||
|
||||
int result = 0;
|
||||
FILE * file = 0;
|
||||
openmpt_module * mod = 0;
|
||||
int mod_err = OPENMPT_ERROR_OK;
|
||||
const char * mod_err_str = NULL;
|
||||
size_t count = 0;
|
||||
size_t written = 0;
|
||||
|
||||
if ( argc != 2 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_stdout SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
if ( wcslen( argv[1] ) == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_stdout SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
file = _wfopen( argv[1], L"rb" );
|
||||
#else
|
||||
if ( strlen( argv[1] ) == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "Wrong invocation. Use 'libopenmpt_example_c_stdout SOMEMODULE'." );
|
||||
goto fail;
|
||||
}
|
||||
file = fopen( argv[1], "rb" );
|
||||
#endif
|
||||
if ( !file ) {
|
||||
fprintf( stderr, "Error: %s\n", "fopen() failed." );
|
||||
goto fail;
|
||||
}
|
||||
|
||||
mod = openmpt_module_create2( openmpt_stream_get_file_callbacks(), file, &libopenmpt_example_logfunc, NULL, &libopenmpt_example_errfunc, NULL, &mod_err, &mod_err_str, NULL );
|
||||
if ( !mod ) {
|
||||
libopenmpt_example_print_error( "openmpt_module_create2()", mod_err, mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
while ( 1 ) {
|
||||
|
||||
openmpt_module_error_clear( mod );
|
||||
count = openmpt_module_read_interleaved_stereo( mod, SAMPLERATE, BUFFERSIZE, buffer );
|
||||
mod_err = openmpt_module_error_get_last( mod );
|
||||
mod_err_str = openmpt_module_error_get_last_message( mod );
|
||||
if ( mod_err != OPENMPT_ERROR_OK ) {
|
||||
libopenmpt_example_print_error( "openmpt_module_read_interleaved_stereo()", mod_err, mod_err_str );
|
||||
openmpt_free_string( mod_err_str );
|
||||
mod_err_str = NULL;
|
||||
}
|
||||
if ( count == 0 ) {
|
||||
break;
|
||||
}
|
||||
|
||||
written = xwrite( STDOUT_FILENO, buffer, count * 2 * sizeof( int16_t ) );
|
||||
if ( written == 0 ) {
|
||||
fprintf( stderr, "Error: %s\n", "write() failed." );
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
result = 0;
|
||||
|
||||
goto cleanup;
|
||||
|
||||
fail:
|
||||
|
||||
result = 1;
|
||||
|
||||
cleanup:
|
||||
|
||||
if ( mod ) {
|
||||
openmpt_module_destroy( mod );
|
||||
mod = 0;
|
||||
}
|
||||
|
||||
if ( file ) {
|
||||
fclose( file );
|
||||
file = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
/*
|
||||
* libopenmpt_example_c_unsafe.c
|
||||
* -----------------------------
|
||||
* Purpose: libopenmpt C API simplified example
|
||||
* Notes : PortAudio is used for sound output.
|
||||
* Authors: OpenMPT Devs
|
||||
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Usage: libopenmpt_example_c_unsafe SOMEMODULE
|
||||
* CAUTION: This simple example does no error cheking at all.
|
||||
*/
|
||||
|
||||
#include <memory.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <libopenmpt/libopenmpt.h>
|
||||
#include <libopenmpt/libopenmpt_stream_callbacks_file.h>
|
||||
|
||||
#include <portaudio.h>
|
||||
|
||||
#define BUFFERSIZE 480
|
||||
#define SAMPLERATE 48000
|
||||
|
||||
static int16_t left[BUFFERSIZE];
|
||||
static int16_t right[BUFFERSIZE];
|
||||
static int16_t * const buffers[2] = { left, right };
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
#if defined( __clang__ ) && !defined( _MSC_VER )
|
||||
int wmain( int argc, wchar_t * argv[] );
|
||||
#endif
|
||||
int wmain( int argc, wchar_t * argv[] ) {
|
||||
#else
|
||||
int main( int argc, char * argv[] ) {
|
||||
#endif
|
||||
FILE * file = 0;
|
||||
openmpt_module * mod = 0;
|
||||
size_t count = 0;
|
||||
PaStream * stream = 0;
|
||||
(void)argc;
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
file = _wfopen( argv[1], L"rb" );
|
||||
#else
|
||||
file = fopen( argv[1], "rb" );
|
||||
#endif
|
||||
mod = openmpt_module_create2( openmpt_stream_get_file_callbacks(), file, NULL, NULL, NULL, NULL, NULL, NULL, NULL );
|
||||
fclose( file );
|
||||
Pa_Initialize();
|
||||
Pa_OpenDefaultStream( &stream, 0, 2, paInt16 | paNonInterleaved, SAMPLERATE, paFramesPerBufferUnspecified, NULL, NULL );
|
||||
Pa_StartStream( stream );
|
||||
while ( 1 ) {
|
||||
count = openmpt_module_read_stereo( mod, SAMPLERATE, BUFFERSIZE, left, right );
|
||||
if ( count == 0 ) {
|
||||
break;
|
||||
}
|
||||
Pa_WriteStream( stream, buffers, (unsigned long)count );
|
||||
}
|
||||
Pa_StopStream( stream );
|
||||
Pa_CloseStream( stream );
|
||||
Pa_Terminate();
|
||||
openmpt_module_destroy( mod );
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
/*
|
||||
* libopenmpt_example_cxx.cpp
|
||||
* --------------------------
|
||||
* Purpose: libopenmpt C++ API example
|
||||
* Notes : PortAudio C++ is used for sound output.
|
||||
* Authors: OpenMPT Devs
|
||||
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Usage: libopenmpt_example_cxx SOMEMODULE
|
||||
*/
|
||||
|
||||
#include <exception>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <new>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
|
||||
#include <libopenmpt/libopenmpt.hpp>
|
||||
|
||||
#if defined( __clang__ )
|
||||
#if ( ( __clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__ ) >= 40000 )
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
|
||||
#endif
|
||||
#endif
|
||||
#include <portaudiocpp/PortAudioCpp.hxx>
|
||||
#if defined( __clang__ )
|
||||
#if ( ( __clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__ ) >= 40000 )
|
||||
#pragma clang diagnostic pop
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if ( defined( _WIN32 ) || defined( WIN32 ) ) && ( defined( _UNICODE ) || defined( UNICODE ) )
|
||||
#if defined( __GNUC__ ) || ( defined( __clang__ ) && !defined( _MSC_VER ) )
|
||||
// mingw-w64 g++ does only default to special C linkage for "main", but not for "wmain" (see <https://sourceforge.net/p/mingw-w64/wiki2/Unicode%20apps/>).
|
||||
extern "C" int wmain( int /*argc*/, wchar_t * /*argv*/[] );
|
||||
extern "C" int wmain( int argc, wchar_t * argv[] ) {
|
||||
#else
|
||||
int wmain( int argc, wchar_t * argv[] ) {
|
||||
#endif
|
||||
#else
|
||||
int main( int argc, char * argv[] ) {
|
||||
#endif
|
||||
try {
|
||||
if ( argc != 2 ) {
|
||||
throw std::runtime_error( "Usage: libopenmpt_example_cxx SOMEMODULE" );
|
||||
}
|
||||
constexpr std::size_t buffersize = 480;
|
||||
constexpr std::int32_t samplerate = 48000;
|
||||
std::ifstream file( argv[1], std::ios::binary );
|
||||
openmpt::module mod( file );
|
||||
portaudio::AutoSystem portaudio_initializer;
|
||||
portaudio::System & portaudio = portaudio::System::instance();
|
||||
std::vector<float> left( buffersize );
|
||||
std::vector<float> right( buffersize );
|
||||
std::vector<float> interleaved_buffer( buffersize * 2 );
|
||||
bool is_interleaved = false;
|
||||
#if defined( _MSC_VER ) && defined( _PREFAST_ )
|
||||
// work-around bug in VS2019 MSVC 16.5.5 static analyzer
|
||||
is_interleaved = false;
|
||||
portaudio::DirectionSpecificStreamParameters outputstream_parameters( portaudio.defaultOutputDevice(), 2, portaudio::FLOAT32, false, portaudio.defaultOutputDevice().defaultHighOutputLatency(), 0 );
|
||||
portaudio::StreamParameters stream_parameters( portaudio::DirectionSpecificStreamParameters::null(), outputstream_parameters, samplerate, paFramesPerBufferUnspecified, paNoFlag );
|
||||
portaudio::BlockingStream stream( stream_parameters );
|
||||
#else
|
||||
portaudio::BlockingStream stream = [&]()
|
||||
{
|
||||
try {
|
||||
is_interleaved = false;
|
||||
portaudio::DirectionSpecificStreamParameters outputstream_parameters( portaudio.defaultOutputDevice(), 2, portaudio::FLOAT32, false, portaudio.defaultOutputDevice().defaultHighOutputLatency(), 0 );
|
||||
portaudio::StreamParameters stream_parameters( portaudio::DirectionSpecificStreamParameters::null(), outputstream_parameters, samplerate, paFramesPerBufferUnspecified, paNoFlag );
|
||||
return portaudio::BlockingStream( stream_parameters );
|
||||
} catch ( const portaudio::PaException & e ) {
|
||||
if ( e.paError() != paSampleFormatNotSupported ) {
|
||||
throw;
|
||||
}
|
||||
is_interleaved = true;
|
||||
portaudio::DirectionSpecificStreamParameters outputstream_parameters( portaudio.defaultOutputDevice(), 2, portaudio::FLOAT32, true, portaudio.defaultOutputDevice().defaultHighOutputLatency(), 0 );
|
||||
portaudio::StreamParameters stream_parameters( portaudio::DirectionSpecificStreamParameters::null(), outputstream_parameters, samplerate, paFramesPerBufferUnspecified, paNoFlag );
|
||||
return portaudio::BlockingStream( stream_parameters );
|
||||
}
|
||||
}();
|
||||
#endif
|
||||
stream.start();
|
||||
while ( true ) {
|
||||
std::size_t count = is_interleaved ? mod.read_interleaved_stereo( samplerate, buffersize, interleaved_buffer.data() ) : mod.read( samplerate, buffersize, left.data(), right.data() );
|
||||
if ( count == 0 ) {
|
||||
break;
|
||||
}
|
||||
try {
|
||||
if ( is_interleaved ) {
|
||||
stream.write( interleaved_buffer.data(), static_cast<unsigned long>( count ) );
|
||||
} else {
|
||||
const float * const buffers[2] = { left.data(), right.data() };
|
||||
stream.write( buffers, static_cast<unsigned long>( count ) );
|
||||
}
|
||||
} catch ( const portaudio::PaException & pa_exception ) {
|
||||
if ( pa_exception.paError() != paOutputUnderflowed ) {
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
stream.stop();
|
||||
} catch ( const std::bad_alloc & ) {
|
||||
std::cerr << "Error: " << std::string( "out of memory" ) << std::endl;
|
||||
return 1;
|
||||
} catch ( const std::exception & e ) {
|
||||
std::cerr << "Error: " << std::string( e.what() ? e.what() : "unknown error" ) << std::endl;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue