seal 0.1.0

data/mpg123/ports/MSVC++/2008clr/mpg123clr/mpg123clr.cpp

@@ -0,0 +1,896 @@
+/*
+	mpg123clr: MPEG Audio Decoder library Common Language Runtime version.
+
+	copyright 2009-2011 by Malcolm Boczek - free software under the terms of the LGPL 2.1
+	mpg123clr.dll is a derivative work of libmpg123 - all original mpg123 licensing terms apply.
+
+	All rights to this work freely assigned to the mpg123 project.
+*/
+/*
+	libmpg123: MPEG Audio Decoder library
+
+	copyright 1995-2011 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+
+*/
+/*
+	1.8.1.0	04-Aug-09	Initial release.
+	1.9.0.0 24-Sep-09	Function names harmonized with libmpg123 (mb)
+	1.9.0.0 01-Oct-09	Technical cleanup - subst nullptr for NULL (mb)
+	1.9.0.0 13-Oct-09	pin_ptr = nullptr on return (mb)
+	1.9.0.1	24-Nov-09	performance update - removed try/finally (mb)
+	1.10.0.0 30-Nov-09	release match - added mpg123_feature (mb)
+	1.12.0.0 14-Apr-10	release match - added framebyframe and "handle" ReplaceReaders (mb)
+	1.13.0.0 13-Jan-11	release match - added encsize (mb)
+*/
+
+// mpg123clr.cpp : Defines the exported functions for the DLL application.
+//
+
+#include "stdafx.h"
+#include "mpg123clr.h"
+
+
+mpg123clr::mpg123::mpg123(void)
+{
+	mh = nullptr;
+	useHandleReplacement = false;
+	lastReplacementWasHandle = false;
+}
+
+mpg123clr::mpg123::mpg123(mpg123_handle* mh)
+{
+	this->mh = mh;
+	useHandleReplacement = false;
+	lastReplacementWasHandle = false;
+}
+
+// Destructor
+mpg123clr::mpg123::~mpg123(void)
+{
+	// clean up code to release managed resources
+
+	// call Finalizer to clean up unmanaged resources
+	this->!mpg123();
+
+	// CLI implements SuppressFinalize - therefore not required here...
+	//GC::SuppressFinalize(this);
+}
+
+// Finalizer
+mpg123clr::mpg123::!mpg123(void)
+{
+	// clean up unmanaged resources
+	if (mh != nullptr) 
+	{
+		::mpg123_delete(mh);
+		mh = nullptr;
+	}
+}
+
+void mpg123clr::mpg123::mpg123_delete(void)
+{
+	if (mh != nullptr) 
+	{
+		::mpg123_delete(mh);
+		mh = nullptr;
+	}
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_init(void)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_init();
+}
+
+void mpg123clr::mpg123::mpg123_exit(void)
+{
+	::mpg123_exit();
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_new(String ^ decoder)
+{
+	const char* chars = (const char*)(Marshal::StringToHGlobalAnsi(decoder)).ToPointer();
+
+	int err;
+	mh = ::mpg123_new(chars, &err);
+
+	Marshal::FreeHGlobal(IntPtr((void*)chars));
+
+	return (mpg123clr::mpg::ErrorCode) err;
+}
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_new(void)
+{
+	int err;
+	mh = ::mpg123_new(NULL,  &err);
+
+	return (mpg123clr::mpg::ErrorCode) err;
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_parnew(mpg123clr::advpars^ par, String ^ decoder)
+{
+	const char* chars = (const char*)(Marshal::StringToHGlobalAnsi(decoder)).ToPointer();
+
+	int err;
+	mh = ::mpg123_parnew(par->mp, chars,  &err);
+
+	Marshal::FreeHGlobal(IntPtr((void*)chars));
+
+	return (mpg123clr::mpg::ErrorCode) err;
+}
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_parnew(mpg123clr::advpars^ par)
+{
+	int err;
+	mh = ::mpg123_parnew(par->mp, NULL,  &err);
+
+	return (mpg123clr::mpg::ErrorCode) err;
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_param(mpg123clr::mpg::parms type, int val, double fval)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_param(mh, (mpg123_parms)type, val, fval);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_getparam(mpg123clr::mpg::parms type, [Out] int% val, [Out] double% fval)
+{
+	// Avoid need for local intermediary variables
+	pin_ptr<int> _val = &val;
+	pin_ptr<double> _fval = &fval;
+
+	int ret = ::mpg123_getparam(mh, (mpg123_parms)type, (long*) _val, _fval);
+
+	_fval = nullptr;
+	_val = nullptr;
+
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+int mpg123clr::mpg123::mpg123_feature(mpg123clr::mpg::feature_set key)
+{
+	return ::mpg123_feature((mpg123_feature_set) key);
+}
+
+String^ mpg123clr::mpg123::mpg123_strerror(void)
+{
+	return gcnew String(::mpg123_strerror(mh));
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_errcode(void)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_errcode(mh);
+}
+
+array<String^>^ mpg123clr::mpg123::StringArrayFromPtr(const char** ptr)
+{
+	int count = 0;
+
+	// count how many strings in array by walking up the array until NULL found
+	while (*(ptr++) != NULL){ ++count; }
+
+	// create an array of the correct size
+	array<String^> ^ str = gcnew array<String^>(count);
+
+	--ptr; // loop leaves ptr +2 beyond end of array - put ptr back to just after last index
+
+	// walk back down the array, extracting the strings
+	while (count-- > 0){ str[count] = gcnew String(*(--ptr)); }
+
+	return str;
+}
+
+array<String^>^ mpg123clr::mpg123::mpg123_decoders(void)
+{
+	return StringArrayFromPtr(::mpg123_decoders());
+}
+
+array<String^>^ mpg123clr::mpg123::mpg123_supported_decoders(void)
+{
+	return StringArrayFromPtr(::mpg123_supported_decoders());
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_decoder(String^ name)
+{
+	const char* chars = (const char*)(Marshal::StringToHGlobalAnsi(name)).ToPointer();
+
+	int ret;
+
+	// one of the few mpg123 places that fault with an exception...
+	try	{ ret = ::mpg123_decoder(mh, chars); }
+	catch(Exception^){ ret = MPG123_ERR;	}
+
+	Marshal::FreeHGlobal(IntPtr((void*)chars));
+
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+String^ mpg123clr::mpg123::mpg123_current_decoder(void)
+{
+	return gcnew String(::mpg123_current_decoder(mh));
+}
+
+array<long>^ mpg123clr::mpg123::mpg123_rates(void)
+{
+	size_t number;
+	const long* list;
+
+	::mpg123_rates(&list, &number);
+
+	array<long>^ rList = gcnew array<long>((int)number);
+
+	int index = 0;
+
+	// walk the array, extracting the rates
+	while (index < (int)number){ rList[index++] = *(list++); }
+
+	return rList;
+}
+
+array<mpg123clr::mpg::enc>^ mpg123clr::mpg123::mpg123_encodings(void)
+{
+	size_t number;
+	const int* list;
+
+	::mpg123_encodings(&list, &number);
+
+	// WARN 4267 - assuming that the number of encodings will never exceed 32bits
+	array<mpg123clr::mpg::enc>^ rList = gcnew array<mpg123clr::mpg::enc>((int)number);
+
+	int index = 0;
+
+	// walk the array, extracting the rates
+	while (index < (int)number){ rList[index++] = (mpg123clr::mpg::enc) *(list++); }
+
+	return rList;
+}
+
+int mpg123clr::mpg123::mpg123_encsize(mpg123clr::mpg::enc encoding)
+{
+	return ::mpg123_encsize((int) encoding);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_format_none(void)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_format_none(mh);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_format_all(void)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_format_all(mh);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_format(int rate, mpg123clr::mpg::channelcount channels, mpg123clr::mpg::enc encodings)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_format(mh, rate, (int) channels, (int) encodings);
+}
+
+mpg123clr::mpg::channelcount mpg123clr::mpg123::mpg123_format_support(int rate, mpg123clr::mpg::enc encodings)
+{
+	return (mpg123clr::mpg::channelcount) ::mpg123_format_support(mh, rate, (int) encodings);
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_getformat([Out] int% rate, [Out] mpg123clr::mpg::channelcount% channels, [Out] mpg123clr::mpg::enc% encodings)
+{
+	// either:-
+	//
+	// long _rate;
+	// int _chan, _enc;
+	// int ret = mpg123_getformat(mh, &_rate, &_chan, &_enc);
+	// rate = _rate;
+	// channels = _chan;
+	// encodings = _enc;
+	// return (mpg123clr::mpg::ErrorCode) ret;
+	//
+	// or:-
+	// use pinned pointers instead
+	pin_ptr<int> _rate = &rate;
+	pin_ptr<mpg123clr::mpg::channelcount> _chan = &channels;
+	pin_ptr<mpg123clr::mpg::enc> _enc = &encodings;
+
+	int ret = ::mpg123_getformat(mh, (long*)_rate, (int*)_chan, (int*)_enc);
+
+	_enc = nullptr;
+	_chan = nullptr;
+	_rate = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_open(String^ path)
+{
+	const char* chars = (const char*)(Marshal::StringToHGlobalAnsi(path)).ToPointer();
+
+	_ReplaceReader();
+
+	int ret = ::mpg123_open(mh, chars);
+
+	Marshal::FreeHGlobal(IntPtr((void*)chars));
+
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_open_fd(int filedescriptor)
+{
+	_ReplaceReader();
+
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_open_fd(mh, filedescriptor);
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_open_handle(System::Object^ obj)
+{
+	// NOTE: You must have configured callbacks using mpg123_replace_reader_handle
+	// before calling mpg123_open_handle!
+
+	_ReplaceReader();	// activate callbacks
+
+	// Make sure we free this in Close functions
+	userObjectHandle = GCHandle::Alloc(obj);
+
+	// NOTE: This sends a HANDLE not an ADDRESS, no pinning required
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_open_handle(mh, (void*)GCHandle::ToIntPtr(userObjectHandle).ToPointer());
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_open_feed(void)
+{
+	_ReplaceReader();
+
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_open_feed(mh);
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_close(void)
+{
+	// Closes 'mh' and calls Cleanup delegate if provided
+	int ret = ::mpg123_close(mh);
+
+	// See GCHandle.Free - caller must ensure Free called only once for a given handle.
+	if (userObjectHandle.IsAllocated) userObjectHandle.Free();
+		
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_read(array<unsigned char>^ buffer, [Out] size_t% count)
+{
+	pin_ptr<size_t> _count = &count;
+	pin_ptr<unsigned char> _ptr = &buffer[0];
+
+	int ret = ::mpg123_read(mh, _ptr, buffer->Length, _count);
+
+	_ptr = nullptr;
+	_count = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_read(array<unsigned char>^ buffer, size_t offset, size_t size, [Out] size_t% count)
+{
+	pin_ptr<size_t> _count = &count;
+	// WARN 4267 - clr limited to 32bit-length-size arrays!!
+	pin_ptr<unsigned char> _ptr = &buffer[(int)offset];
+
+	int ret = ::mpg123_read(mh, _ptr, size, _count);
+
+	_ptr = nullptr;
+	_count = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_feed(array<unsigned char>^ inbuffer, size_t size)
+{
+	pin_ptr<unsigned char> _ptr = &inbuffer[0];
+
+	int ret = ::mpg123_feed(mh, _ptr, size);
+
+	_ptr = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_decode(array<unsigned char>^ inbuffer, size_t insize, array<unsigned char>^ outbuffer, size_t outsize, [Out] size_t% count)
+{
+	pin_ptr<size_t> _count = &count;
+	pin_ptr<const unsigned char> _inptr = &inbuffer[0];
+	pin_ptr<unsigned char> _outptr = &outbuffer[0];
+
+	int ret = ::mpg123_decode(mh, _inptr, insize, _outptr, outsize, _count);
+
+	_outptr = nullptr;
+	_inptr = nullptr;
+	_count = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_decode_frame([Out] off_t% num, [Out] IntPtr% audio, [Out] size_t% count)
+{
+	pin_ptr<size_t> _count = &count;
+	pin_ptr<off_t> _num = &num;
+	pin_ptr<IntPtr> _x = &audio;
+
+	int ret = ::mpg123_decode_frame(mh, _num, (unsigned char**)_x, _count);
+
+	_x = nullptr;
+	_num = nullptr;
+	_count = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_framebyframe_decode([Out] off_t% num, [Out] IntPtr% audio, [Out] size_t% count)
+{
+	// NOTE: must use framebyframe_next to obtain successive frames
+
+	pin_ptr<size_t> _count = &count;
+	pin_ptr<off_t> _num = &num;
+	pin_ptr<IntPtr> _x = &audio;
+
+	int ret = ::mpg123_framebyframe_decode(mh, _num, (unsigned char**)_x, _count);
+
+	_x = nullptr;
+	_num = nullptr;
+	_count = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode  mpg123clr::mpg123::mpg123_framebyframe_next()
+{
+	// mpg123lib has warning, Experimental API. Watch for updates!!!
+	// framebyframe_decode doesn't automatically move on to next frame,
+	// use framebyframe_next to move on to "Find, read and parse the next mp3 frame"
+	int ret = ::mpg123_framebyframe_next(mh);
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+long long mpg123clr::mpg123::mpg123_tell(void)
+{
+	return ::mpg123_tell(mh);
+}
+
+long long mpg123clr::mpg123::mpg123_tellframe(void)
+{
+	return ::mpg123_tellframe(mh);
+}
+
+long long mpg123clr::mpg123::mpg123_tell_stream(void)
+{
+	return ::mpg123_tell_stream(mh);
+}
+
+long long mpg123clr::mpg123::mpg123_seek(long long offset, SeekOrigin origin)
+{
+	return ::mpg123_seek(mh, (off_t)offset, (int)origin);
+}
+
+long long mpg123clr::mpg123::mpg123_feedseek(long long offset, SeekOrigin origin, [Out] long long% input_offset)
+{
+	// NOTE: off_t fiddles...
+	// pin_ptr<int> _input_offset = &input_offset; // type mismatch between 32 and 64 bit offsets.
+
+	off_t _input_offset;	// type accomodation
+
+	off_t ret = ::mpg123_feedseek(mh, (off_t)offset, (int)origin, &_input_offset); // ok types
+
+	input_offset = _input_offset;	// type conversion
+
+	return ret;
+}
+
+long long mpg123clr::mpg123::mpg123_seek_frame(long long frameoffset, SeekOrigin origin)
+{
+	return ::mpg123_seek_frame(mh, (off_t)frameoffset, (int)origin);
+}
+
+long long mpg123clr::mpg123::mpg123_timeframe(double seconds)
+{
+	return ::mpg123_timeframe(mh, seconds);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_index([Out] array<long long>^% index, [Out] long long% step)
+{
+	// remnant: only works if off_t, index and step are 32 bit - possible redo for 64 bit library
+	// pin_ptr<int> _step = &step;
+	// int ret = mpg123_index(mh, &_list, (off_t*)_step, &_count);
+	// index = gcnew array<int>((int)_count);
+	// Marshal::Copy((IntPtr)_list, index, 0, (int)_count);
+
+	// alternate: works for 32 and 64 bit libraries - returns long long values
+	off_t* _list;
+	size_t _count;
+	off_t _step;	// type accomodation
+
+	int ret = ::mpg123_index(mh, &_list, &_step, &_count);
+
+	step = _step;	// type conversion
+
+	// WARN 4267 - clr limited to 32bit-length-size arrays!!
+	index = gcnew array<long long>((int)_count);
+
+	// walk the array, extracting the rates
+	int idx = 0;	// array length limited to 32bit
+	while (idx < index->Length){ index[idx++] = *(_list++); }
+
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_index([Out] IntPtr% indexarr, [Out] long long% step, [Out] size_t% fill)
+{
+	pin_ptr<size_t> _fill = &fill;
+	pin_ptr<IntPtr> _x = &indexarr;	// NOTE: untyped index pointer.
+	off_t _step;	// type accomodation
+
+	int ret = ::mpg123_index(mh, (off_t**)_x, &_step, _fill);
+
+	step = _step;	// type conversion
+
+	_x = nullptr;
+	_fill = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_position(
+	long long frameoffset, long long bufferedbytes, [Out] long long% currentframe, [Out] long long% framesleft,
+			[Out] double% currentseconds, [Out] double% secondsleft)
+{
+	// NOTE: off_t fiddles
+	// pin_ptr<int> _currentframe = &currentframe;
+	// pin_ptr<int> _framesleft = &framesleft;
+	pin_ptr<double> _currentseconds = &currentseconds;
+	pin_ptr<double> _secondsleft = &secondsleft;
+	off_t _currentframe;	// type accomodation
+	off_t _framesleft;		// type accomodation
+
+	int ret =  ::mpg123_position(mh, (off_t)frameoffset, (off_t)bufferedbytes, &_currentframe, &_framesleft, _currentseconds, _secondsleft);
+
+	currentframe = _currentframe;	// type conversion
+	framesleft = _framesleft;		// type conversion
+
+	_secondsleft = nullptr;
+	_currentseconds = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+#pragma region Volume and Equalizer
+
+		/// \defgroup mpg123_voleq mpg123 volume and equalizer
+		///
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_eq(mpg123clr::mpg::channels channel, int band, double fval)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_eq(mh, (mpg123_channels)channel, band, fval);
+}
+
+double mpg123clr::mpg123::mpg123_geteq(mpg123clr::mpg::channels channel, int band)
+{
+	return ::mpg123_geteq(mh, (mpg123_channels)channel, band);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_reset_eq(void)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_reset_eq(mh);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_volume(double volume)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_volume(mh, volume);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_volume_change(double change)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_volume_change(mh, change);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_getvolume([Out] double% basevol, [Out] double% really, [Out] double% rva_db)
+{
+	pin_ptr<double> _basevol = &basevol;
+	pin_ptr<double> _really = &really;
+	pin_ptr<double> _rva_db = &rva_db;
+
+	int ret = ::mpg123_getvolume(mh, _basevol, _really, _rva_db);
+
+	_rva_db = nullptr;
+	_really = nullptr;
+	_basevol = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+#pragma endregion -Volume and Equalizer
+#pragma region Status and Information
+
+		// \defgroup mpg123_status mpg123 status and information
+		//
+		//
+		//
+
+// The "proper" way to manage structs...
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_safeinfo([Out]mpeg_frameinfo^% finfo)
+{
+	// "out" our return reference and grab some memory
+	finfo = gcnew mpeg_frameinfo;
+	IntPtr pp = Marshal::AllocHGlobal(Marshal::SizeOf(finfo));
+
+	// get the info
+
+	// could cast away...
+	//	int ret = mpg123_info(mh, reinterpret_cast<mpg123_frameinfo*>((int)pp));
+	//	int ret = mpg123_info(mh, static_cast<mpg123_frameinfo*>((void*)pp));
+
+	// or let the compiler decide...
+	int ret = ::mpg123_info(mh, (mpg123_frameinfo*)(void*)pp);
+
+	// marshal data into return object and free temporary memory
+	Marshal::PtrToStructure(pp, finfo);
+	Marshal::FreeHGlobal(pp);
+
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+// The "efficient" way to manage structs...
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_info([Out]mpeg_frameinfo^% finfo)
+{
+	finfo = gcnew mpeg_frameinfo;
+
+	pin_ptr<mpg123clr::mpg::mpeg_version> _ptr = &finfo->version;
+
+	// According to SizeOf...
+	// The unmanaged and managed sizes of an object can differ, this would imply
+	// that the memory layout for each would also be different, which would indicate
+	// that using a ptr, derived from a ptr-to-a-managed type, in unmanaged code could
+	// have unforseen results.
+	//
+	// In non-homogenous structs (like mpg123text) it can lead to corrupted CLR stack.
+	// In homogenous structs (like finfo) it appears to be "managable".
+	//
+	// However, until it fails it'll do... and it's much faster (see mpg123_safeinfo(...)).
+
+	// WARNING:
+	// The epitome of "unsafe" as defined by CLR (using unmanaged pointers).
+	// If we start to get CLR stack corruptions - check here first! (see SafeInfo for "safe" managed version)
+	int ret = ::mpg123_info(mh, (mpg123_frameinfo*)_ptr);
+
+	_ptr = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+size_t mpg123clr::mpg123::mpg123_safe_buffer(void)
+{
+	return ::mpg123_safe_buffer();
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_scan(void)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_scan(mh);
+}
+
+long long mpg123clr::mpg123::mpg123_length(void)
+{
+	return ::mpg123_length(mh);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_set_filesize(long long size)
+{
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_set_filesize(mh, (off_t)size);
+}
+
+double mpg123clr::mpg123::mpg123_tpf(void)
+{
+	return ::mpg123_tpf(mh);
+}
+
+long mpg123clr::mpg123::mpg123_clip(void)
+{
+	return ::mpg123_clip(mh);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_getstate(mpg123clr::mpg::state key, [Out] int% val, [Out] double% fval)
+{
+	pin_ptr<int> _val = &val;
+	pin_ptr<double> _fval = &fval;
+
+	int ret = ::mpg123_getstate(mh, (mpg123_state)key, (long*) _val, _fval);
+
+	_fval = nullptr;
+	_val = nullptr;
+	
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+#pragma endregion -Status and Information
+
+#pragma region Metadata Handling
+
+		// \defgroup mpg123_metadata mpg123 metadata handling
+		//
+		// Functions to retrieve the metadata from MPEG Audio files and streams.
+		// Also includes string handling functions.
+		//
+
+mpg123clr::id3::id3check  mpg123clr::mpg123::mpg123_meta_check(void)
+{
+	return (mpg123clr::id3::id3check ) ::mpg123_meta_check(mh);
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_id3([Out]id3::mpg123id3v1^% v1, [Out]id3::mpg123id3v2^% v2)
+{
+	mpg123_id3v1* pv1;
+	mpg123_id3v2* pv2;
+
+	// doc says "pv1 and pv2 may be set to NULL when there is no corresponding data."
+	// they may also be set to point to empty structure...
+	int ret = ::mpg123_id3(mh, &pv1, &pv2);
+
+	v1 = gcnew mpg123clr::id3::mpg123id3v1(pv1);
+	v2 = gcnew mpg123clr::id3::mpg123id3v2(pv2);
+
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_icy([Out]IntPtr% icy_meta)
+{
+	char* _icy_meta;
+
+	int ret = ::mpg123_icy(mh, &_icy_meta);
+
+	icy_meta = (IntPtr) _icy_meta;
+
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+array<unsigned char>^ mpg123clr::mpg123::mpg123_icy2utf8(IntPtr icy_text)
+{
+	// TODO: Do we really need this?
+	// char* putf8 = mpg123_icy2utf8(const_cast<char*>(reinterpret_cast<char*>(icy_text.ToPointer())));
+
+	// Or is this adequate?
+	char* putf8 = ::mpg123_icy2utf8((const char*)(void*) icy_text);
+
+	// WARN 4267 - clr limited to 32bit-length-size arrays!!
+	array<unsigned char>^ ary = gcnew array<unsigned char>((int)strlen(putf8));
+
+	Marshal::Copy((IntPtr)putf8, ary, 0, ary->Length);
+	free(putf8);
+
+	return ary;
+}
+
+#pragma endregion -Metadata Handling
+
+#pragma region Low Level I/O
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_replace_buffer(IntPtr data, size_t size)
+{
+	// "data" buffer should be fixed BEFORE calling this function.
+
+	// TODO: to cast or not to cast??
+	// return (mpg123clr::mpg::ErrorCode) mpg123_replace_buffer(mh, reinterpret_cast<unsigned char*>(data.ToPointer()), size);
+
+	return (mpg123clr::mpg::ErrorCode) ::mpg123_replace_buffer(mh, (unsigned char*)(void*) data, size);
+}
+
+size_t mpg123clr::mpg123::mpg123_outblock(void)
+{
+	return ::mpg123_outblock(mh);
+}
+
+void mpg123clr::mpg123::_ReplaceReader(void)
+{
+	if ((readDel == r_readDel) && (seekDel == r_seekDel)
+		&& (readHDel == r_readHDel) && (seekDel == r_seekHDel) && (cleanHDel == r_cleanHDel)) return;
+
+	// readDel and seekDel are "keep alive" fields that prevent GC of the delegates.
+	// the underlying function pointers no not require "pinning".
+
+	// Note: most examples use GCHandle::Alloc to "pin" the delegate but this is usually to prevent GC
+	// outside of function scope and is not strictly necessary here since readDel and seekDel never go
+	// out of scope.
+
+	// See MS: c++, How to: Marshal Callbacks and Delegates Using C++ Interop
+	// for more details.
+
+	readDel = r_readDel;
+	seekDel = r_seekDel;
+	readHDel = r_readHDel;
+	seekHDel = r_seekHDel;
+	cleanHDel = r_cleanHDel;
+
+	// just for clarity
+	typedef off_t (_cdecl* SEEKCB)(int, off_t, int);
+	typedef ssize_t (_cdecl* READCB)(int, void*, size_t);
+	typedef off_t (_cdecl* HSEEKCB)(void*, off_t, int);
+	typedef ssize_t (_cdecl* HREADCB)(void*, void*, size_t);
+	typedef void (_cdecl* HCLEANCB)(void*);
+
+	// NOTE: GetFunctionPointerForDelegate doesn't like nullptr
+	// NOTE: I'm not suggesting that replace_reader and replace_reader_handle should be
+	//       intermingled, just trying to maintain a clean stack
+
+	if (!useHandleReplacement)
+	{
+		if (lastReplacementWasHandle)
+			::mpg123_replace_reader_handle(mh, nullptr, nullptr, nullptr);
+
+		::mpg123_replace_reader(
+			mh, 
+			(readDel != nullptr) ? (READCB)(Marshal::GetFunctionPointerForDelegate(readDel)).ToPointer() : nullptr, 
+			(seekDel != nullptr) ? (SEEKCB)(Marshal::GetFunctionPointerForDelegate(seekDel)).ToPointer() : nullptr
+			);
+	}
+	else
+	{
+		if (!lastReplacementWasHandle)	// can give redundant call on first use - microscopically inefficient - not catastrophic
+			::mpg123_replace_reader(mh, nullptr, nullptr);
+
+		::mpg123_replace_reader_handle(
+			mh, 
+			(readHDel != nullptr) ? (HREADCB)(Marshal::GetFunctionPointerForDelegate(readHDel)).ToPointer() : nullptr, 
+			(seekHDel != nullptr) ? (HSEEKCB)(Marshal::GetFunctionPointerForDelegate(seekHDel)).ToPointer() : nullptr,
+			(cleanHDel != nullptr) ? (HCLEANCB)(Marshal::GetFunctionPointerForDelegate(cleanHDel)).ToPointer() : nullptr
+			);
+	}
+	lastReplacementWasHandle = useHandleReplacement;
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_replace_reader(ReadDelegate^ r_read, SeekDelegate^ r_lseek)
+{
+	// save temporary delegates to be implemented at next 'Open'
+	r_readDel = r_read;
+	r_seekDel = r_lseek;
+	r_readHDel = nullptr;
+	r_seekHDel = nullptr;
+	r_cleanHDel = nullptr;
+	useHandleReplacement = false;
+
+	return mpg123clr::mpg::ErrorCode::ok;
+
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_replace_reader_handle(ReadHandleDelegate^ rh_read, SeekHandleDelegate^ rh_lseek, CleanupHandleDelegate^ rh_clean)
+{
+	// save temporary delegates to be implemented at next 'Open'
+	r_readHDel = rh_read;
+	r_seekHDel = rh_lseek;
+	r_cleanHDel = rh_clean;
+	r_readDel = nullptr;
+	r_seekDel = nullptr;
+	useHandleReplacement = true;
+
+	return mpg123clr::mpg::ErrorCode::ok;
+
+}
+
+#pragma endregion -Low Level I/O
+
+#pragma region MS Unicode Extension
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_topen(String^ path)
+{
+	_ReplaceReader();	// mpg123_tOpen will replace its own reader, this is just for consistency
+
+	const _TCHAR* chars = (const _TCHAR*)(Marshal::StringToHGlobalUni(path)).ToPointer();
+
+	int ret = ::mpg123_topen(mh, chars);
+
+	Marshal::FreeHGlobal(IntPtr((void*)chars));
+
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+mpg123clr::mpg::ErrorCode mpg123clr::mpg123::mpg123_tclose(void)
+{
+	// Not sure if t_close calls Cleanup (it shouldn't since t_open substitutes its own readers)
+	int ret = ::mpg123_tclose(mh);
+
+	// Fairly sure replace_reader_handle, topen and tclose are incompatible, just for consistency
+	// See GCHandle.Free - caller must ensure Free called only once for a given handle.
+	if (userObjectHandle.IsAllocated) userObjectHandle.Free();
+		
+	return (mpg123clr::mpg::ErrorCode) ret;
+}
+
+#pragma endregion -MS Unicode Extension
+
+