seal 0.1.0

data/mpg123/ports/MSVC++/2008clr/mpg123clr/advanced.h

@@ -0,0 +1,130 @@
+/*
+	mpg123clr: MPEG Audio Decoder library Common Language Runtime version.
+
+	copyright 2009 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-2008 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)
+*/
+
+#pragma once
+
+#pragma warning(disable : 4635)
+#include "mpg123.h"
+#pragma warning(default : 4635)
+
+#include "enum.h"
+#include "error.h"
+
+using namespace System;
+using namespace System::Runtime::InteropServices;
+
+namespace mpg123clr
+{
+	// Recommended usage when creating reference type on the managed heap (not using stack semantics 
+	//  for reference types...) [see (Microsoft) Destructors and Finalizers in Visual C++]
+	//
+	// C++/CLI
+	// A myA;
+	//		// use myA here
+	//
+	// Equivalent user code:
+	//
+	// A ^ myA = gcnew A;
+	// try { /* use myA here */ } finally { delete myA; }
+	//
+	//
+	// C# (from wikipedia)
+	// using(A myA = new A()) { /* Use myA here */ }
+    // Compiler calls myA.Dispose(), in a "finally" of a "try/finally" block
+	//
+    // Equivalent user code:
+	//
+    //  A myA = new myA();
+    //  try { /* Use myA here */ } finally { myA.Dispose(); }
+	//
+	// Otherwise Finalizer will be nondeterministically called by GC
+
+
+	///<summary> CLR wrapper for mpg123_pars object.</summary>
+	public ref class advpars
+	{
+	protected public:
+		mpg123_pars*	mp;
+
+	protected:
+		!advpars(void);
+
+	public:
+		///<summary>Constructor.</summary>
+		///<param name="error">Returns MPG123_OK or mpg123 error code.</param>
+		advpars([Out] int% error);
+
+		///<summary>Destructor.</summary>
+		~advpars(void);
+
+		///<summary>Configure mpg123 parameters to accept no output formats.
+		///<para>Use to clear default parameters prior to applying specific settings.</para>
+		///<para>Returns MPG123 error codes.</para>
+		///</summary>
+		///<returns>MPG123 error codes.</returns>
+		mpg123clr::mpg::ErrorCode __clrcall mpg123_fmt_none(void);
+
+		///<summary>Configure mpg123 parameters to accept all formats including custom rate you may set - this is the default.
+		///<para>Returns MPG123 error codes.</para>
+		///</summary>
+		///<returns>MPG123 error codes.</returns>
+		mpg123clr::mpg::ErrorCode __clrcall mpg123_fmt_all(void);
+
+		///<summary>Configure detailed output formats.
+		///<para>Returns MPG123 error codes.</para>
+		///</summary>
+		///<param name="rate">Sample rate (Hertz)</param>
+		///<param name="channels">Combination of channelcount.stereo and channelcount.mono</param>
+		///<param name="encodings">Combination of accepted encodings for rate and channels e.g. enc.enc_signed16 | enc.enc_ulaw_8 (or 0 for none)</param>
+		///<returns>MPG123 error codes.</returns>
+		/// VERSION CHECK: long as int for Intellisense
+		mpg123clr::mpg::ErrorCode __clrcall mpg123_fmt(int rate, mpg123clr::mpg::channelcount channels, int encodings);
+
+		///<summary>Get available support for supplied rate and encoding.
+		///<para>Returns 0 for no support (includes invalid parameters), or combination of channelcount.stereo and channelcount.mono.</para>
+		///</summary>
+		///<param name="rate">Sample rate (Hertz)</param>
+		///<param name="encoding">Combination of accepted encodings for rate and channels e.g. enc.enc_signed16 | enc.enc_ulaw_8 (or 0 for none)</param>
+		///<returns>Returns 0 for no support (includes invalid parameters), or combination of channelcount.stereo and channelcount.mono.</returns>
+		/// VERSION CHECK: long as int for Intellisense
+		mpg123clr::mpg::channelcount __clrcall mpg123_fmt_support(int rate, int encoding);
+
+		///<summary>Set a specific advpars value.
+		///<para>Returns MPG123 error codes.</para>
+		///</summary>
+		///<param name="type">Specifies the advpars parameter to be set.</param>
+		///<param name="val">The integer value to be applied.</param>
+		///<param name="fval">The real value to be applied.</param>
+		///<returns>MPG123 error codes.</returns>
+		/// VERSION CHECK: long as int for Intellisense
+		mpg123clr::mpg::ErrorCode __clrcall mpg123_par(mpg123clr::mpg::parms type, int val, double fval);
+
+		///<summary>Get a specific advpars value.
+		///<para>Returns MPG123 error codes.</para>
+		///</summary>
+		///<param name="type">Specifies the advpars parameter to be returned.</param>
+		///<param name="val">Returns the applicable integer value.</param>
+		///<param name="fval">Returns the applicable real value.</param>
+		///<returns>MPG123 error codes.</returns>
+		/// VERSION CHECK: long as int for Intellisense
+		mpg123clr::mpg::ErrorCode __clrcall mpg123_getpar(mpg123clr::mpg::parms type, [Out] int% val, [Out] double% fval);
+	};
+
+}

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

@@ -0,0 +1,19 @@
+// dllmain.cpp : Defines the entry point for the DLL application.
+#include "stdafx.h"
+
+BOOL APIENTRY DllMain( HMODULE hModule,
+                       DWORD  ul_reason_for_call,
+                       LPVOID lpReserved
+					 )
+{
+	switch (ul_reason_for_call)
+	{
+	case DLL_PROCESS_ATTACH:
+	case DLL_THREAD_ATTACH:
+	case DLL_THREAD_DETACH:
+	case DLL_PROCESS_DETACH:
+		break;
+	}
+	return TRUE;
+}
+

data/mpg123/ports/MSVC++/2008clr/mpg123clr/enum.h

@@ -0,0 +1,218 @@
+/*
+	mpg123clr: MPEG Audio Decoder library Common Language Runtime version.
+
+	copyright 2009 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.10.0.0 30-Nov-09	release match - added mpg123_feature (mb)
+	1.13.0.0 13-Jan-11	release match (mb)
+*/
+
+#pragma once
+
+#pragma warning(disable : 4635)
+#include "mpg123.h"
+#pragma warning(default : 4635)
+
+
+namespace mpg123clr
+{
+	///<summary>Mpg123 enumerations.</summary>
+	namespace mpg
+	{
+
+		///<summary>Enumeration of the parameters types that it is possible to set/get.</summary>
+		public enum class parms
+		{
+			verbose = MPG123_VERBOSE,				/// set verbosity value for enabling messages to stderr, >= 0 makes sense (integer)
+			flags = MPG123_FLAGS,					/// set all flags, p.ex val = MPG123_GAPLESS|MPG123_MONO_MIX (integer)
+			add_flags = MPG123_ADD_FLAGS,			/// add some flags (integer)
+			force_rate = MPG123_FORCE_RATE,			/// when value > 0, force output rate to that value (integer)
+			down_sample = MPG123_DOWN_SAMPLE,		/// 0=native rate, 1=half rate, 2=quarter rate (integer)
+			rva = MPG123_RVA,						/// one of the RVA choices above (integer)
+			downspeed = MPG123_DOWNSPEED,			/// play a frame N times (integer)
+			upspeed = MPG123_UPSPEED,				/// play every Nth frame (integer)
+			start_frame = MPG123_START_FRAME,		/// start with this frame (skip frames before that, integer)
+			decode_frames = MPG123_DECODE_FRAMES,	/// decode only this number of frames (integer)
+			icy_interval = MPG123_ICY_INTERVAL,		/// stream contains ICY metadata with this interval (integer)
+			outscale = MPG123_OUTSCALE,				/// the scale for output samples (amplitude - integer or float according to mpg123 output format, normally integer)
+			timeout = MPG123_TIMEOUT,				/// timeout for reading from a stream (not supported on win32, integer)
+			remove_flags = MPG123_REMOVE_FLAGS,		/// remove some flags (inverse of MPG123_ADD_FLAGS, integer)
+			resync_limit = MPG123_RESYNC_LIMIT,		/// Try resync on frame parsing for that many bytes or until end of stream (<0 ... integer).
+			index_size = MPG123_INDEX_SIZE,			/// Set the frame index size (if supported). Values <0 mean that the index is allowed to grow dynamically in these steps (in positive direction, of course) -- Use this when you really want a full index with every individual frame.
+			preframes = MPG123_PREFRAMES			/// Decode/ignore that many frames in advance for layer 3. This is needed to fill bit reservoir after seeking, for example (but also at least one frame in advance is needed to have all "normal" data for layer 3). Give a positive integer value, please.
+
+		};
+
+
+		///<summary>Parameter flag bits.</summary>
+		///<remarks>Equivalent to MPG123_FLAGS, use the usual binary or ( | ) to combine.</remarks>
+		public enum class param_flags
+		{
+			force_mono = MPG123_FORCE_MONO,			///     0111 Force some mono mode: This is a test bitmask for seeing if any mono forcing is active. 
+			mono_left = MPG123_MONO_LEFT,			///     0001 Force playback of left channel only.  
+			mono_right = MPG123_MONO_RIGHT,			///     0010 Force playback of right channel only. 
+			mono_mix = MPG123_MONO_MIX,				///     0100 Force playback of mixed mono.         
+			force_stereo = MPG123_FORCE_STEREO,		///     1000 Force stereo output.                  
+			force_8bit = MPG123_FORCE_8BIT,			/// 00010000 Force 8bit formats.                   
+			quiet = MPG123_QUIET,					/// 00100000 Suppress any printouts (overrules verbose).                    
+			gapless = MPG123_GAPLESS,				/// 01000000 Enable gapless decoding (default on if libmpg123 has support). 
+			no_resync = MPG123_NO_RESYNC,			/// 10000000 Disable resync stream after error.                             
+			seekbuffer = MPG123_SEEKBUFFER,			/// 000100000000 Enable small buffer on non-seekable streams to allow some peek-ahead (for better MPEG sync). 
+			fuzzy = MPG123_FUZZY,					/// 001000000000 Enable fuzzy seeks (guessing byte offsets or using approximate seek points from Xing TOC) 
+			force_float = MPG123_FORCE_FLOAT,		/// 010000000000 Force floating point output (32 or 64 bits depends on mpg123 internal precision). 
+
+			///<summary>Prevent ID3 text translation to UTF-8.
+			///<para>NOTE: Do not set if you intend to use CLR id3v2 objects.</para>
+			///</summary>
+			plain_id3text = MPG123_PLAIN_ID3TEXT,	/// 100000000000 Do not translate ID3 text data to UTF-8. ID3 strings will contain the raw text data, with the first byte containing the ID3 encoding code.
+
+			ignore_streamlength = MPG123_IGNORE_STREAMLENGTH,	/// 1000000000000 Ignore any stream length information contained in the stream, which can be contained in a 'TLEN' frame of an ID3v2 tag or a Xing tag.
+
+			// 1.13.0.0
+			skip_id3v2 = MPG123_SKIP_ID3V2,			/// 10 0000 0000 0000 Do not parse ID3v2 tags, just skip them.
+		};
+
+		///<summary>RVA enumeration.</summary>
+		///<remarks>Equivalent to MPG123_RVA.</remarks>
+		public enum class rva
+		{
+			rva_off   = MPG123_RVA_OFF,		/// RVA disabled (default).   
+			rva_mix   = MPG123_RVA_MIX,		/// Use mix/track/radio gain. 
+			rva_album = MPG123_RVA_ALBUM,	/// Use album/audiophile gain 
+			rva_max   = MPG123_RVA_ALBUM,	/// The maximum RVA code, may increase in future. 
+		};
+
+		///<summary>Feature set available for query with mpg123_feature. </summary>
+		///<remarks>Equivalent to MPG123_FEATURE_SET.</remarks>
+		public enum class feature_set
+		{
+			feature_abi_utf8open = MPG123_FEATURE_ABI_UTF8OPEN,				/// mpg123 expects path names to be given in UTF-8 encoding instead of plain native.
+			feature_output_8bit = MPG123_FEATURE_OUTPUT_8BIT,				/// 8bit output  
+			feature_output_16bit = MPG123_FEATURE_OUTPUT_16BIT,				/// 16bit output
+			feature_output_32bit = MPG123_FEATURE_OUTPUT_32BIT,				/// 32bit output
+			feature_index = MPG123_FEATURE_INDEX,							/// support for building a frame index for accurate seeking
+			feature_parse_id3v2 = MPG123_FEATURE_PARSE_ID3V2,				/// id3v2 parsing
+			feature_decode_layer1 = MPG123_FEATURE_DECODE_LAYER1,			/// mpeg layer-1 decoder enabled
+			feature_decode_layer2 = MPG123_FEATURE_DECODE_LAYER2,			/// mpeg layer-2 decoder enabled
+			feature_decode_layer3 = MPG123_FEATURE_DECODE_LAYER3,			/// mpeg layer-3 decoder enabled
+			feature_decode_accurate = MPG123_FEATURE_DECODE_ACCURATE,		/// accurate decoder rounding
+			feature_decode_downsample = MPG123_FEATURE_DECODE_DOWNSAMPLE,	/// downsample (sample omit)
+			feature_decode_ntom = MPG123_FEATURE_DECODE_NTOM,				/// flexible rate decoding
+			feature_parse_icy = MPG123_FEATURE_PARSE_ICY,					/// ICY support
+			feature_timeout_read = MPG123_FEATURE_TIMEOUT_READ,				/// Reader with timeout (network)
+		};
+
+
+
+		///<summary>An enum over all sample types possibly known to mpg123.</summary>
+		///<remarks><para>The values are designed as bit flags to allow bitmasking for encoding families.</para>
+		///
+		///<para>Note that (your build of) libmpg123 does not necessarily support all these.
+		/// Usually, you can expect the 8bit encodings and signed 16 bit.
+		/// Also 32bit float will be usual beginning with mpg123-1.7.0 .</para>
+		///
+		///<para>What you should bear in mind is that (SSE, etc) optimized routines may be absent
+		/// for some formats. We do have SSE for 16, 32 bit and float, though.
+		/// 24 bit integer is done via postprocessing of 32 bit output -- just cutting
+		/// the last byte, no rounding, even. If you want better, do it yourself.</para>
+		///
+		///<para>All formats are in native byte order. On a little endian machine this should mean
+		/// that you can just feed the MPG123_ENC_SIGNED_32 data to common 24bit hardware that
+		/// ignores the lowest byte (or you could choose to do rounding with these lower bits).</para>
+		///</remarks>
+		public enum class enc
+		{
+			enc_8			= MPG123_ENC_8,				/// 0000 0000 1111 Some 8 bit  integer encoding. 
+			enc_16			= MPG123_ENC_16,			/// 0000 0100 0000 Some 16 bit integer encoding.
+			enc_24			= MPG123_ENC_24,			/// 0100 0000 0000 0000 Some 24 bit integer encoding. (r1.13)
+			enc_32			= MPG123_ENC_32,			/// 0001 0000 0000 Some 32 bit integer encoding.
+			enc_signed		= MPG123_ENC_SIGNED,		/// 0000 1000 0000 Some signed integer encoding.
+			enc_float		= MPG123_ENC_FLOAT,			/// 1110 0000 0000 Some float encoding.
+			enc_signed_16   = MPG123_ENC_SIGNED_16,		///           1101 0000 signed 16 bit
+			enc_unsigned_16 = MPG123_ENC_UNSIGNED_16,	///           0110 0000 unsigned 16 bit
+			enc_unsigned_8  = MPG123_ENC_UNSIGNED_8,    ///           0000 0001 unsigned 8 bit
+			enc_signed_8    = MPG123_ENC_SIGNED_8,      ///           1000 0010 signed 8 bit
+			enc_ulaw_8		= MPG123_ENC_ULAW_8,		///           0000 0100 ulaw 8 bit
+			enc_alaw_8		= MPG123_ENC_ALAW_8,		///           0000 1000 alaw 8 bit
+			enc_signed_32   = MPG123_ENC_SIGNED_32,		/// 0001 0001 1000 0000 signed 32 bit
+			enc_unsigned_32 = MPG123_ENC_UNSIGNED_32,   /// 0010 0001 0000 0000 unsigned 32 bit
+			enc_signed_24	= MPG123_ENC_SIGNED_24,		/// 0101 0000 1000 0000 signed 24 bit (r1.13)
+			enc_unsigned_24	= MPG123_ENC_UNSIGNED_24,	/// 0110 0000 0000 0000 unsigned 24 bit (r1.13)
+			enc_float_32    = MPG123_ENC_FLOAT_32,      ///      0010 0000 0000 32bit float
+			enc_float_64    = MPG123_ENC_FLOAT_64,      ///      0100 0000 0000 64bit float
+			enc_any			= MPG123_ENC_ANY,			/// any encoding
+		};
+
+
+		///<summary>Channel count enumeration</summary>
+		///<remarks>clr added <cref name="both">both</cref></remarks>
+		public enum class channelcount
+		{
+			mono   = MPG123_MONO,
+			stereo = MPG123_STEREO,
+			both   = MPG123_MONO | MPG123_STEREO,
+		};
+
+		///<summary>Channel enumeration.</summary>
+		public enum class channels
+		{
+			left	= MPG123_LEFT,	/// The Left Channel. 
+			right	= MPG123_RIGHT,	/// The Right Channel. 
+			both	= MPG123_LR,	/// Both left and right channel; same as MPG123_LEFT|MPG123_RIGHT 
+		};
+
+		///<summary>VBR enumeration.</summary>
+		public enum class mpeg_vbr
+		{
+			cbr = MPG123_CBR,		/// Constant Bitrate Mode (default) 
+			vbr = MPG123_VBR,		/// Variable Bitrate Mode 
+			abr = MPG123_ABR,		/// Average Bitrate Mode 
+		};
+
+		///<summary>MPEG Version enumeration.</summary>
+		public enum class mpeg_version
+		{
+			mpeg_1_0 = MPG123_1_0,	/// MPEG Version 1.0 
+			mpeg_2_0 = MPG123_2_0,	/// MPEG Version 2.0 
+			mpeg_2_5 = MPG123_2_5,	/// MPEG Version 2.5 
+		};
+
+		///<summary>MPEG Mode enumeration.</summary>
+		public enum class mpeg_mode
+		{
+			m_stereo	= MPG123_M_STEREO,	/// Standard Stereo. 
+			m_joint		= MPG123_M_JOINT,	/// Joint Stereo. 
+			m_dual		= MPG123_M_DUAL,	/// Dual Channel. 
+			m_mono		= MPG123_M_MONO,	/// Single Channel. 
+		};
+
+		///<summary>MPEG Flags enumeration.</summary>
+		public enum class mpeg_flags
+		{
+			CRC			= MPG123_CRC,		/// The bitstream is error protected using 16-bit CRC. 
+			COPYRIGHT	= MPG123_COPYRIGHT,	/// The bitstream is copyrighted. 
+			PRIVATE		= MPG123_PRIVATE,	/// The private bit has been set. 
+			ORIGINAL	= MPG123_ORIGINAL,	/// The bitstream is an original, not a copy. 
+		};
+
+		///<summary>Positional state.</summary>
+		public enum class state
+		{
+			accurate	= MPG123_ACCURATE	/// Query if positons are currently accurate (integer value, 0 if false, 1 if true) 
+		};
+
+
+	}
+}

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

@@ -0,0 +1,48 @@
+/*
+	mpg123clr: MPEG Audio Decoder library Common Language Runtime version.
+
+	copyright 2009 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-2008 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)
+*/
+
+#include "StdAfx.h"
+#include "error.h"
+
+mpg123clr::mpg123error::mpg123error(void)
+{
+}
+
+// Destructor cleans up all resources
+mpg123clr::mpg123error::~mpg123error(void)
+{
+	// clean up code to release managed resources
+	// ...
+
+	// call Finalizer to clean up unmanaged resources
+	this->!mpg123error();
+}
+
+// Finalizer cleans up unmanaged resources
+mpg123clr::mpg123error::!mpg123error(void)
+{
+	// none!
+}
+
+String^ mpg123clr::mpg123error::mpg123_plain_strerror(mpg123clr::mpg::ErrorCode errcode)
+{
+	return gcnew String(::mpg123_plain_strerror((int)errcode));
+}
+

data/mpg123/ports/MSVC++/2008clr/mpg123clr/error.h

@@ -0,0 +1,134 @@
+/*
+	mpg123clr: MPEG Audio Decoder library Common Language Runtime version.
+
+	copyright 2009 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-2008 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.12.0.0 14-Apr-10	Revision harmonization (catch-up)
+*/
+
+#pragma once
+
+#pragma warning(disable : 4635)
+#include "mpg123.h"
+#pragma warning(default : 4635)
+
+#include "enum.h"
+
+using namespace System;
+
+namespace mpg123clr
+{
+	// defgroup mpg123_error mpg123 error handling
+	//
+	// Functions to get text version of the error numbers and an enumeration
+	// of the error codes returned by libmpg123.
+	//
+	// Most functions operating on a mpg123_handle simply return MPG123_OK on success and MPG123_ERR on failure (setting the internal error variable of the handle to the specific error code).
+	// Decoding/seek functions may also return message codes MPG123_DONE, MPG123_NEW_FORMAT and MPG123_NEED_MORE (please read up on these on how to react!).
+	// The positive range of return values is used for "useful" values when appropriate.
+	//
+	//
+	//
+
+
+	namespace mpg
+	{
+		///<summary>Enumeration of the message and error codes as returned by libmpg123 functions.</summary>
+		public enum class ErrorCode
+		{
+			done = MPG123_DONE,								/// Message: Track ended. 
+			new_format = MPG123_NEW_FORMAT,					/// Message: Output format will be different on next call. 
+			need_more = MPG123_NEED_MORE,					/// Message: For feed reader: "Feed me more!" 
+			err = MPG123_ERR,								/// Generic Error 
+			ok = MPG123_OK,									/// Success 
+			bad_outformat = MPG123_BAD_OUTFORMAT,			/// Unable to set up output format! 
+			bad_channel = MPG123_BAD_CHANNEL,				/// Invalid channel number specified. 
+			bad_rate = MPG123_BAD_RATE,						/// Invalid sample rate specified.  
+			err_16to8table = MPG123_ERR_16TO8TABLE,			/// Unable to allocate memory for 16 to 8 converter table! 
+			bad_param = MPG123_BAD_PARAM,					/// Bad parameter id! 
+			bad_buffer = MPG123_BAD_BUFFER,					/// Bad buffer given -- invalid pointer or too small size. 
+			out_of_mem = MPG123_OUT_OF_MEM,					/// Out of memory -- some malloc() failed. 
+			not_initialized = MPG123_NOT_INITIALIZED,		/// You didn't initialize the library! 
+			bad_decoder = MPG123_BAD_DECODER,				/// Invalid decoder choice. 
+			bad_handle = MPG123_BAD_HANDLE,					/// Invalid mpg123 handle. 
+			no_buffers = MPG123_NO_BUFFERS,					/// Unable to initialize frame buffers (out of memory?). 
+			bad_rva = MPG123_BAD_RVA,						/// Invalid RVA mode. 
+			no_gapless = MPG123_NO_GAPLESS,					/// This build doesn't support gapless decoding. 
+			no_space = MPG123_NO_SPACE,						/// Not enough buffer space. 
+			bad_types = MPG123_BAD_TYPES,					/// Incompatible numeric data types. 
+			bad_band = MPG123_BAD_BAND,						/// Bad equalizer band. 
+			err_null = MPG123_ERR_NULL,						/// Null pointer given where valid storage address needed. 
+			err_reader = MPG123_ERR_READER,					/// Error reading the stream. 
+			no_seek_from_end = MPG123_NO_SEEK_FROM_END,		/// Cannot seek from end (end is not known).
+			bad_whence = MPG123_BAD_WHENCE,					/// Invalid 'whence' for seek function.
+			no_timeout = MPG123_NO_TIMEOUT,					/// Build does not support stream timeouts. 
+			bad_file = MPG123_BAD_FILE,						/// File access error. 
+			no_seek = MPG123_NO_SEEK,						/// Seek not supported by stream. 
+			no_reader = MPG123_NO_READER,					/// No stream opened. 
+			bad_pars = MPG123_BAD_PARS,						/// Bad parameter handle. 
+			bad_index_par = MPG123_BAD_INDEX_PAR,			/// Bad parameters to mpg123_index() 
+			out_of_sync = MPG123_OUT_OF_SYNC,				/// Lost track in bytestream and did not try to resync. 
+			resync_fail = MPG123_RESYNC_FAIL,				/// Resync failed to find valid MPEG data. 
+			no_8bit = MPG123_NO_8BIT,						/// No 8bit encoding possible. 
+			bad_align = MPG123_BAD_ALIGN,					/// Stack aligmnent error 
+			null_buffer = MPG123_NULL_BUFFER,				/// NULL input buffer with non-zero size... 
+			no_relseek = MPG123_NO_RELSEEK,					/// Relative seek not possible (screwed up file offset) 
+			null_pointer = MPG123_NULL_POINTER,				/// You gave a null pointer somewhere where you shouldn't have. 
+			bad_key = MPG123_BAD_KEY,						/// Bad key value given. 
+			no_index = MPG123_NO_INDEX,						/// No frame index in this build. 
+			index_fail = MPG123_INDEX_FAIL,					/// Something with frame index went wrong. 
+			bad_decoder_setup = MPG123_BAD_DECODER_SETUP,	/// Something prevents a proper decoder setup 
+			missing_feature = MPG123_MISSING_FEATURE,		/// This feature has not been built into libmpg123. 
+			/* 1.8.1 */
+			bad_value = MPG123_BAD_VALUE,					/// A bad value has been given, somewhere. 
+			lseek_failed = MPG123_LSEEK_FAILED,				/// Low-level seek failed.
+			/* 1.12.0 */
+			bad_custom_io = MPG123_BAD_CUSTOM_IO,			/// Custom I/O not prepared.
+			lfs_overflow = MPG123_LFS_OVERFLOW,				/// Offset value overflow during translation of large file API calls,
+															/// - your client program cannot handle that large file.
+
+		};
+	}
+
+	///<summary>Wrapper for mpg123_errors</summary>
+	public ref class mpg123error
+	{
+	protected:
+		///<summary>Finalizer.
+		///<para>Cleanly handles mpg123_delete of internal (unmanaged) handles.</para></summary>
+		/// Implementation of CLR Finalize().
+		!mpg123error(void);
+
+	public:
+		///<summary>Constructor.</summary>
+		mpg123error(void);
+
+		///<summary>Destructor. Used for final object deletion.
+		///<para>Calls finalizer for clean disposal of internal (unmanaged) library handles.</para>
+		///</summary>
+		/// Implementation of CLR Dispose().
+		/// ~Destructor and !Finalizer are the prescribed implementation of Dispose() and Finalize().
+		/// See Destructors and Finalizers in Visual C++
+		~mpg123error(void);
+
+		///<summary>Obtain a string description of the errcode meaning.
+		///<para>Returns a String description representing the error code.</para>
+		///</summary>
+		///<param name="errcode">The error code to be described.</param>
+		///<returns>Returns a String description representing the error code.</returns>
+		static String^ __clrcall mpg123_plain_strerror(mpg123clr::mpg::ErrorCode errcode);
+	};
+}