/*____________________________________________________________________________
	
	FreeAmp - The Free MP3 Player

        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
        Corp.  http://www.xingtech.com

	Portions Copyright (C) 1998-1999 EMusic.com

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	
	$Id: towave.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
____________________________________________________________________________*/

/* ------------------------------------------------------------------------

      NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE

        This file exists for reference only. It is not actually used
        in the FreeAmp project. There is no need to mess with this 
        file. There is no need to flatten the beavers, either.

      NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE

/*---- towave.c --------------------------------------------
  32 bit version only

decode mpeg Layer I/II/III file using portable ANSI C decoder,
output to pcm wave file.

mod 8/19/98 decode 22 sf bands

mod 5/14/98  allow mpeg25 (dec8 not supported for mpeg25 samp rate)

mod 3/4/98 bs_trigger  bs_bufbytes  made signed, unsigned may 
            not terminate properly.  Also extra test in bs_fill.

mod 8/6/96 add 8 bit output to standard decoder

ver 1.4 mods 7/18/96 32 bit and add asm option

mods 6/29/95  allow MS wave file for u-law.  bugfix u-law table dec8.c

mods 2/95 add sample rate reduction, freq_limit and conversions.
          add _decode8 for 8Ks output, 16bit 8bit, u-law output.
          add additional control parameters to init.
          add _info function

mod 5/12/95 add quick window cwinq.c

mod 5/19/95 change from stream io to handle io

mod 11/16/95 add Layer I

mod 1/5/95   integer overflow mod iup.c

ver 1.3
mod 2/5/96   portability mods
             drop Tom and Gloria pcm file types

ver 2.0
mod 1/7/97   Layer 3 (float mpeg-1 only)
    2/6/97   Layer 3 MPEG-2

ver 3.01     Layer III bugfix crc problem 8/18/97
ver 3.02     Layer III fix wannabe.mp3 problem 10/9/97
ver 3.03     allow mpeg 2.5  5/14/98
  
Decoder functions for _decode8 are defined in dec8.c.  Useage
is same as regular decoder.

Towave illustrates use of decoder.  Towave converts
mpeg audio files to 16 bit (short) pcm.  Default pcm file
format is wave. Other formats can be accommodated by
adding alternative write_pcm_header and write_pcm_tailer
functions.  The functions kbhit and getch used in towave.c
may not port to other systems.

The decoder handles all mpeg1 and mpeg2 Layer I/II  bitstreams.  

For compatability with the asm decoder and future C versions,
source code users are discouraged from making modifications
to the decoder proper.  MS Windows applications can use wrapper
functions in a separate module if decoder functions need to
be exported.

NOTE additional control parameters.

mod 8/6/96 standard decoder adds 8 bit output

decode8 (8Ks output) convert_code:
   convert_code = 4*bit_code + chan_code
       bit_code:   1 = 16 bit linear pcm
                   2 =  8 bit (unsigned) linear pcm
                   3 = u-law (8 bits unsigned)
       chan_code:  0 = convert two chan to mono
                   1 = convert two chan to mono
                   2 = convert two chan to left chan
                   3 = convert two chan to right chan

decode (standard decoder) convert_code:
             0 = two chan output
             1 = convert two chan to mono
             2 = convert two chan to left chan
             3 = convert two chan to right chan
     or with 8 = 8 bit output 
          (other bits ignored)

decode (standard decoder) reduction_code:
             0 = full sample rate output
             1 = half rate
             2 = quarter rate

-----------------------------------------------------------*/
#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>
#include <string.h>
#ifdef WIN32
#include <io.h>
#endif
#include <fcntl.h>		/* file open flags */
#include <sys/types.h>		/* someone wants for port */
#include <sys/stat.h>		/* forward slash for portability */
#include "mhead.h"		/* mpeg header structure, decode protos */

#include "port.h"

// JDW
#ifdef __linux__
#include <sys/ioctl.h>
#include <sys/soundcard.h>
#include <fcntl.h>
#include <errno.h>
#endif
// JDW

#include "mp3struct.h"
#include <assert.h>

typedef struct id3v1_1 {
    char id[3];
    char title[30];		// <file basename>
    char artist[30];	// "Raven Software"
    char album[30];		// "#UNCOMP %d"		// needed
    char year[4];		// "2000"
    char comment[28];	// "#MAXVOL %g"		// needed
    char zero;
    char track;
    char genre;
} id3v1_1;	// 128 bytes in size

id3v1_1 *gpTAG;
#define BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(_pvData, _iBytesRemaining)								\
																									\
	/* account for trailing ID3 tag in _iBytesRemaining */											\
	gpTAG = (id3v1_1*) (((byte *)_pvData + _iBytesRemaining)-sizeof(id3v1_1));	/* sizeof = 128	*/	\
	if (!strncmp(gpTAG->id, "TAG", 3))																\
	{																								\
		_iBytesRemaining -= sizeof(id3v1_1);														\
	}





/********  pcm buffer ********/

#define PCM_BUFBYTES  60000U	// more than enough to cover the largest that one packet will ever expand to
char PCM_Buffer[PCM_BUFBYTES];	// better off being declared, so we don't do mallocs in this module (MAC reasons)

   typedef struct
   {
      int (*decode_init) (MPEG_HEAD * h, int framebytes_arg,
			  int reduction_code, int transform_code,
			  int convert_code, int freq_limit);
      void (*decode_info) (DEC_INFO * info);      
	  IN_OUT(*decode) (unsigned char *bs, short *pcm, unsigned char *pNextByteAfterData);
   }
   AUDIO;
   
#if 0
   // stuff this...
   static AUDIO audio_table[2][2] =
   {
      {
	 {audio_decode_init, audio_decode_info, audio_decode},
	 {audio_decode8_init, audio_decode8_info, audio_decode8},
      },
      {
	 {i_audio_decode_init, i_audio_decode_info, i_audio_decode},
	 {audio_decode8_init, audio_decode8_info, audio_decode8},
      }
   };
#else
   static AUDIO audio_table[2][2] =
   {
      {
		{audio_decode_init, audio_decode_info, audio_decode},
		{audio_decode_init, audio_decode_info, audio_decode},
      },
      {
		{audio_decode_init, audio_decode_info, audio_decode},
		{audio_decode_init, audio_decode_info, audio_decode},			
      }
   };
#endif

   static const AUDIO audio = {audio_decode_init, audio_decode_info, audio_decode};	//audio_table[0][0];


// Do NOT change these, ever!!!!!!!!!!!!!!!!!!
//
const int reduction_code	= 0;		// unpack at full sample rate output
const int convert_code_mono	= 1;		
const int convert_code_stereo = 0;
const int freq_limit		= 24000;	// no idea what this is about, but it's always this value so...

// the entire decode mechanism uses this now...
//
MP3STREAM _MP3Stream;
LP_MP3STREAM pMP3Stream = &_MP3Stream;
int bFastEstimateOnly = 0;	// MUST DEFAULT TO THIS VALUE!!!!!!!!!


// char *return is NZ for any errors (no trailing CR!)
//
char *C_MP3_IsValid(void *pvData, int iDataLen, int bStereoDesired)
{
//	char sTemp[1024];	/////////////////////////////////////////////////
	unsigned int iRealDataStart;
	MPEG_HEAD head;
	DEC_INFO  decinfo;

	int iBitRate;
	int iFrameBytes;

//#ifdef _DEBUG
//	int iIgnoreThisForNowIJustNeedItToBreakpointOnToReadAValue = sizeof(MP3STREAM);
//#endif

	memset(pMP3Stream,0,sizeof(*pMP3Stream));

	iFrameBytes = head_info3( pvData, iDataLen/2, &head, &iBitRate, &iRealDataStart);
	if (iFrameBytes == 0)
	{
		return "MP3ERR: Bad or unsupported file!";
	}

	// check for files with bad frame unpack sizes (that would crash the game), or stereo files.
	//
	// although the decoder can convert stereo to mono (apparently), we want to know about stereo files
	//	because they're a waste of source space... (all FX are mono, and moved via panning)
	//
	if (head.mode != 3 && !bStereoDesired)	//3 seems to mean mono
	{
		if (iDataLen > 98000) {	// we'll allow it for small files even if stereo
			return "MP3ERR: Sound file is stereo!";
		}
	}		
	if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
	{
		if (bStereoDesired)
		{
			if (pMP3Stream->outbytes > 4608)
			{
				return "MP3ERR: Source file has output packet size > 2304 (*2 for stereo) bytes!";
			}
		}		
		else
		{
			if (pMP3Stream->outbytes > 2304)
			{
				return "MP3ERR: Source file has output packet size > 2304 bytes!";
			}
		}		

		audio.decode_info(&decinfo);

		if (decinfo.bits != 16)
		{
			return "MP3ERR: Source file is not 16bit!";	// will this ever happen? oh well...
		}

		if (decinfo.samprate != 44100)
		{
			return "MP3ERR: Source file is not sampled @ 44100!";
		}

		if (bStereoDesired && decinfo.channels != 2)
		{
			return "MP3ERR: Source file is not stereo!";	// sod it, I'm going to count this as an error now
		}		
	}
	else
	{
		return "MP3ERR: Decoder failed to initialise";
	}

	// file seems to be valid...
	//
	return NULL;
}



// char *return is NZ for any errors (no trailing CR!)
//
char* C_MP3_GetHeaderData(void *pvData, int iDataLen, int *piRate, int *piWidth, int *piChannels, int bStereoDesired)
{
	unsigned int iRealDataStart;
	MPEG_HEAD head;
	DEC_INFO  decinfo;

	int iBitRate;
	int iFrameBytes;

	memset(pMP3Stream,0,sizeof(*pMP3Stream));

	iFrameBytes = head_info3( pvData, iDataLen/2, &head, &iBitRate, &iRealDataStart);
	if (iFrameBytes == 0)
	{
		return "MP3ERR: Bad or unsupported file!";
	}

	if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
	{
		audio.decode_info(&decinfo);

		*piRate		= decinfo.samprate;	// rate (eg 22050, 44100 etc)
		*piWidth	= decinfo.bits/8;	// 1 for 8bit, 2 for 16 bit
		*piChannels	= decinfo.channels;	// 1 for mono, 2 for stereo
	}
	else
	{
		return "MP3ERR: Decoder failed to initialise";
	}

	// everything ok...
	//
	return NULL;
}




// this duplicates work done in C_MP3_IsValid(), but it avoids global structs, and means that you can call this anytime
//	if you just want info for some reason
//
// ( size is now workd out just by decompressing each packet header, not the whole stream. MUCH faster :-)
//
// char *return is NZ for any errors (no trailing CR!)
//
char *C_MP3_GetUnpackedSize(void *pvData, int iSourceBytesRemaining, int *piUnpackedSize, int bStereoDesired )
{
	int iReadLimit;
	unsigned int iRealDataStart;
	MPEG_HEAD head;
	int iBitRate;

	char *pPCM_Buffer = PCM_Buffer;
	char *psReturn = NULL;
//	int  iSourceReadIndex = 0;
	int	 iDestWriteIndex = 0;

	int iFrameBytes;
	int iFrameCounter;

	DEC_INFO decinfo;
	IN_OUT	 x;
	
	memset(pMP3Stream,0,sizeof(*pMP3Stream));

#define iSourceReadIndex iRealDataStart

//	iFrameBytes = head_info2( pvData, 0, &head, &iBitRate);
	iFrameBytes = head_info3( pvData, iSourceBytesRemaining/2, &head, &iBitRate, &iRealDataStart);
	
	BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvData, iSourceBytesRemaining)
	iSourceBytesRemaining -= iRealDataStart;

	iReadLimit = iSourceReadIndex + iSourceBytesRemaining;

	if (iFrameBytes)
	{
		//pPCM_Buffer = malloc(PCM_BUFBYTES);

		//if (pPCM_Buffer)
		{
			// init decoder...

			if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
			{
				audio.decode_info(&decinfo);

				// decode...
				//
				for (iFrameCounter = 0;;iFrameCounter++)
				{
					if ( iSourceBytesRemaining == 0 || iSourceBytesRemaining < iFrameBytes)
						break;	// end of file

					bFastEstimateOnly = 1;	///////////////////////////////

							x = audio.decode((unsigned char *)pvData + iSourceReadIndex, (short *) ((char *)pPCM_Buffer
																							//+ iDestWriteIndex		// keep decoding over the same spot since we're only counting bytes in this function
																							),
											(unsigned char *)pvData + iReadLimit
											);

					bFastEstimateOnly = 0;	///////////////////////////////
					
					iSourceReadIndex		+= x.in_bytes;
					iSourceBytesRemaining	-= x.in_bytes;
					iDestWriteIndex			+= x.out_bytes;

					if (x.in_bytes <= 0)
					{
						//psReturn = "MP3ERR: Bad sync in file";
						break;
					}
				}

				*piUnpackedSize = iDestWriteIndex;	// yeeehaaa!
			}
			else
			{
				psReturn = "MP3ERR: Decoder failed to initialise";
			}
		}
//		else
//		{
//			psReturn = "MP3ERR: Unable to alloc temp decomp buffer";		
//		}
	}
	else
	{
		psReturn = "MP3ERR: Bad or Unsupported MP3 file!";
	}


//	if (pPCM_Buffer)
//	{
//		free(pPCM_Buffer);
//		pPCM_Buffer = NULL;	// I know, I know...
//	}

	return psReturn;

#undef iSourceReadIndex
}




char *C_MP3_UnpackRawPCM( void *pvData, int iSourceBytesRemaining, int *piUnpackedSize, void *pbUnpackBuffer, int bStereoDesired)
{
	int iReadLimit;
	unsigned int iRealDataStart;
	MPEG_HEAD head;
	int iBitRate;
	
	char *psReturn = NULL;
//	int  iSourceReadIndex = 0;
	int	 iDestWriteIndex = 0;

	int iFrameBytes;
	int iFrameCounter;

	DEC_INFO decinfo;
	IN_OUT	 x;

	memset(pMP3Stream,0,sizeof(*pMP3Stream));

#define iSourceReadIndex iRealDataStart

//	iFrameBytes = head_info2( pvData, 0, &head, &iBitRate);
	iFrameBytes = head_info3( pvData, iSourceBytesRemaining/2, &head, &iBitRate, &iRealDataStart);

	BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvData, iSourceBytesRemaining)
	iSourceBytesRemaining -= iRealDataStart;

	iReadLimit = iSourceReadIndex + iSourceBytesRemaining;

	if (iFrameBytes)
	{
//		if (1)////////////////////////pPCM_Buffer)
		{
			// init decoder...

			if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
			{
				audio.decode_info(&decinfo);

//				printf("\n output samprate = %6ld",decinfo.samprate);
//				printf("\n output channels = %6d", decinfo.channels);
//				printf("\n output bits     = %6d", decinfo.bits);
//				printf("\n output type     = %6d", decinfo.type);

//===============
				
				// decode...
				//
				for (iFrameCounter = 0;;iFrameCounter++)
				{
					if ( iSourceBytesRemaining == 0 || iSourceBytesRemaining < iFrameBytes)
						break;	// end of file

					x = audio.decode((unsigned char *)pvData + iSourceReadIndex, (short *) ((char *)pbUnpackBuffer + iDestWriteIndex),									 
									 (unsigned char *)pvData + iReadLimit
									);	
					
					iSourceReadIndex		+= x.in_bytes;
					iSourceBytesRemaining	-= x.in_bytes;
					iDestWriteIndex			+= x.out_bytes;

					if (x.in_bytes <= 0)
					{
						//psReturn = "MP3ERR: Bad sync in file";
						break;
					}
				}

				*piUnpackedSize = iDestWriteIndex;	// yeeehaaa!
			}
			else
			{
				psReturn = "MP3ERR: Decoder failed to initialise";
			}
		}
	}
	else
	{
		psReturn = "MP3ERR: Bad or Unsupported MP3 file!";
	}

	return psReturn;

#undef iSourceReadIndex
}


// called once, after we've decided to keep something as MP3. This just sets up the decoder for subsequent stream-calls.
// 					  
// (the struct pSFX_MP3Stream is cleared internally, so pass as args anything you want stored in it)
//
// char * return is NULL for ok, else error string
//
// NEW CODE NOTE: Now that this function is being called for raw data that's going to be runtime-stored in a link-list
//	chunk format for SOF2 instead of just one alloc then you must re-init pMP3Stream->pbSourceData after you've called
//	this, or it'll be pointing at the deallocated original raw data, not the first chunk of the link list
//
char *C_MP3Stream_DecodeInit( LP_MP3STREAM pSFX_MP3Stream, void *pvSourceData, int iSourceBytesRemaining,
							  int iGameAudioSampleRate, int iGameAudioSampleBits, int bStereoDesired )
{
	char			*psReturn = NULL;
	MPEG_HEAD		head;			// only relevant within this function during init	
	DEC_INFO		decinfo;		//   " "
	int				iBitRate;		// not used after being filled in by head_info3()

	pMP3Stream = pSFX_MP3Stream;

	memset(pMP3Stream,0,sizeof(*pMP3Stream));

	pMP3Stream->pbSourceData			= (byte *) pvSourceData;	// this MUST be re-initialised to link-mem outside here for SOF2, since raw data is now link-listed
	pMP3Stream->iSourceBytesRemaining	= iSourceBytesRemaining;
	pMP3Stream->iSourceFrameBytes		= head_info3( (byte *) pvSourceData, iSourceBytesRemaining/2, &head, &iBitRate, (unsigned int*)&pMP3Stream->iSourceReadIndex );	

	// hack, do NOT do this for stereo, since music files are now streamed and therefore the data isn't actually fully
	//	loaded at this point, only about 4k or so for the header is actually in memory!!!...
	//
	if (!bStereoDesired)
	{
		BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvSourceData, pMP3Stream->iSourceBytesRemaining);
		pMP3Stream->iSourceBytesRemaining  -= pMP3Stream->iSourceReadIndex;
	}

	// backup a couple of fields so we can play this again later...
	//
	pMP3Stream->iRewind_SourceReadIndex		= pMP3Stream->iSourceReadIndex;
	pMP3Stream->iRewind_SourceBytesRemaining= pMP3Stream->iSourceBytesRemaining;

	assert(pMP3Stream->iSourceFrameBytes);
	if (pMP3Stream->iSourceFrameBytes)
	{
		if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, reduction_code, pMP3Stream->iSourceReadIndex, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
		{
			pMP3Stream->iRewind_FinalReductionCode = reduction_code;	// default = 0 (no reduction), 1=half, 2 = quarter

			pMP3Stream->iRewind_FinalConvertCode   = bStereoDesired?convert_code_stereo:convert_code_mono;
																		// default = 1 (mono), OR with 8 for 8-bit output

			// only now can we ask what kind of properties this file has, and then adjust to fit what the game wants...
			//
			audio.decode_info(&decinfo);

//			printf("\n output samprate = %6ld",decinfo.samprate);
//			printf("\n output channels = %6d", decinfo.channels);
//			printf("\n output bits     = %6d", decinfo.bits);
//			printf("\n output type     = %6d", decinfo.type);

			// decoder offers half or quarter rate adjustement only...
			//
			if (iGameAudioSampleRate == decinfo.samprate>>1)
				pMP3Stream->iRewind_FinalReductionCode = 1;
			else
			if (iGameAudioSampleRate == decinfo.samprate>>2)
				pMP3Stream->iRewind_FinalReductionCode = 2;

			if (iGameAudioSampleBits == decinfo.bits>>1)	// if game wants 8 bit sounds, then setup for that
				pMP3Stream->iRewind_FinalConvertCode |= 8;

			if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, pMP3Stream->iRewind_FinalReductionCode, pMP3Stream->iSourceReadIndex, pMP3Stream->iRewind_FinalConvertCode, freq_limit))
			{
				audio.decode_info(&decinfo);
#ifdef _DEBUG
				assert( iGameAudioSampleRate == decinfo.samprate );
				assert( iGameAudioSampleBits == decinfo.bits );
#endif

				// sod it, no harm in one last check... (should never happen)
				//
				if ( iGameAudioSampleRate != decinfo.samprate || iGameAudioSampleBits != decinfo.bits )
				{
					psReturn = "MP3ERR: Decoder unable to convert to current game audio settings";
				}
			}
			else
			{
				psReturn = "MP3ERR: Decoder failed to initialise for pass 2 sample adjust";
			}
		}
		else
		{
			psReturn = "MP3ERR: Decoder failed to initialise";
		}
	}
	else
	{
		psReturn = "MP3ERR: Errr.... something's broken with this MP3 file";	// should never happen by this point
	}

	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
	//
	pMP3Stream = &_MP3Stream;

	return psReturn;
}

// return value is decoded bytes for this packet, which is effectively a BOOL, NZ for not finished decoding yet...
//
unsigned int C_MP3Stream_Decode( LP_MP3STREAM pSFX_MP3Stream )
{
	unsigned int uiDecoded = 0;	// default to "finished"
	IN_OUT	 x;

	pMP3Stream = pSFX_MP3Stream;

	do
	{
		if ( pSFX_MP3Stream->iSourceBytesRemaining == 0)// || pSFX_MP3Stream->iSourceBytesRemaining < pSFX_MP3Stream->iSourceFrameBytes)
		{
			uiDecoded = 0;	// finished
			break;
		}

		x = audio.decode(pSFX_MP3Stream->pbSourceData + pSFX_MP3Stream->iSourceReadIndex, (short *) (pSFX_MP3Stream->bDecodeBuffer),
						 pSFX_MP3Stream->pbSourceData + pSFX_MP3Stream->iRewind_SourceReadIndex + pSFX_MP3Stream->iRewind_SourceBytesRemaining
						);

#ifdef _DEBUG
		pSFX_MP3Stream->iSourceFrameCounter++;
#endif

		pSFX_MP3Stream->iSourceReadIndex		+= x.in_bytes;
		pSFX_MP3Stream->iSourceBytesRemaining	-= x.in_bytes;
		pSFX_MP3Stream->iBytesDecodedTotal		+= x.out_bytes;
		pSFX_MP3Stream->iBytesDecodedThisPacket	 = x.out_bytes;

		uiDecoded = x.out_bytes;

		if (x.in_bytes <= 0)
		{
			//psReturn = "MP3ERR: Bad sync in file";			
			uiDecoded= 0;	// finished
			break;
		}
	}
	#pragma warning (disable : 4127 )	// conditional expression is constant
	while (0);	// <g>
	#pragma warning (default : 4127 )	// conditional expression is constant
	
	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
	//
	pMP3Stream = &_MP3Stream;

	return uiDecoded;
}


// ret is char* errstring, else NULL for ok
//
char *C_MP3Stream_Rewind( LP_MP3STREAM pSFX_MP3Stream )
{
	char*		psReturn = NULL;
	MPEG_HEAD	head;			// only relevant within this function during init	
	int			iBitRate;		// ditto
	int			iNULL;			

	pMP3Stream = pSFX_MP3Stream;

	pMP3Stream->iSourceReadIndex		= pMP3Stream->iRewind_SourceReadIndex;
	pMP3Stream->iSourceBytesRemaining	= pMP3Stream->iRewind_SourceBytesRemaining;	// already adjusted for tags etc	

	// I'm not sure that this is needed, but where else does decode_init get passed useful data ptrs?...
	//
	if (pMP3Stream->iSourceFrameBytes == head_info3( pMP3Stream->pbSourceData, pMP3Stream->iSourceBytesRemaining/2, &head, &iBitRate, (unsigned int*)&iNULL ) )
	{	
		if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, pMP3Stream->iRewind_FinalReductionCode, pMP3Stream->iSourceReadIndex, pMP3Stream->iRewind_FinalConvertCode, freq_limit))
		{
			// we should always get here...
			//
		}
		else
		{
			psReturn = "MP3ERR: Failed to re-init decoder for rewind!";
		}
	}
	else
	{
		psReturn = "MP3ERR: Frame bytes mismatch during rewind header-read!";
	}

	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
	//
	pMP3Stream = &_MP3Stream;

	return psReturn;
}

