Update build environment

 - remove faad2
 - remove mad
 - remove polarssl
 - remove pthreads
 - add libcurl
 - add vtparse with UTF8 support
 - update project to use Visual Studio 2015

20 files changed, 0 insertions, 6078 deletions

diff --git a/faad2/src/plugins/QCDMp4/QCDInputDLL.h b/faad2/src/plugins/QCDMp4/QCDInputDLL.h
deleted file mode 100644
index 46a811a..0000000
--- a/faad2/src/plugins/QCDMp4/QCDInputDLL.h
+++ /dev/null
@@ -1,46 +0,0 @@
-//-----------------------------------------------------------------------------

-// 

-// File:	QCDInputDLL.h

-//

-// About:	QCD Player Input module DLL interface.  For more documentation, see

-//			QCDModInput.h.

-//

-// Authors:	Written by Paul Quinn and Richard Carlson.

-//

-//	QCD multimedia player application Software Development Kit Release 1.0.

-//

-//	Copyright (C) 1997-2002 Quinnware

-//

-//	This code is free.  If you redistribute it in any form, leave this notice 

-//	here.

-//

-//	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.

-//

-//-----------------------------------------------------------------------------

-

-#ifndef QCDInputDLL_H

-#define QCDInputDLL_H

-

-#include "QCDModInput.h"

-

-// Calls from the Player

-int  GetMediaSupported(const char* medianame, MediaInfo *mediaInfo);

-int  GetTrackExtents(const char* medianame, TrackExtents *ext, int flags);

-int  GetCurrentPosition(const char* medianame, long *track, long *offset);

-

-void SetEQ(EQInfo*);

-void SetVolume(int levelleft, int levelright, int flags);

-

-int  Play(const char* medianame, int framefrom, int frameto, int flags);

-int  Pause(const char* medianame, int flags);

-int  Stop(const char* medianame, int flags);

-int  Eject(const char* medianame, int flags);

-

-int  Initialize(QCDModInfo *ModInfo, int flags);

-void ShutDown(int flags);

-void Configure(int flags);

-void About(int flags);

-

-#endif //QCDInputDLL_H
\ No newline at end of file
diff --git a/faad2/src/plugins/QCDMp4/QCDModDefs.h b/faad2/src/plugins/QCDMp4/QCDModDefs.h
deleted file mode 100644
index 6b87006..0000000
--- a/faad2/src/plugins/QCDMp4/QCDModDefs.h
+++ /dev/null
@@ -1,413 +0,0 @@
-//-----------------------------------------------------------------------------

-//

-// File:	QCDModDefs.h

-//

-// About:	Module definitions file.  Miscellanious definitions used by different

-//			module types.  This file is published with the plugin SDKs.

-//

-// Authors:	Written by Paul Quinn and Richard Carlson.

-//

-// Copyright:

-//

-//	QCD multimedia player application Software Development Kit Release 1.0.

-//

-//	Copyright (C) 1997-2002 Quinnware

-//

-//	This code is free.  If you redistribute it in any form, leave this notice 

-//	here.

-//

-//	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.

-//

-//-----------------------------------------------------------------------------

-

-#ifndef QCDMODDEFS_H

-#define QCDMODDEFS_H

-

-#include <mmreg.h>

-#include <windows.h>

-

-#ifdef __cplusplus

-#define PLUGIN_API extern "C" __declspec(dllexport)

-#else

-#define PLUGIN_API __declspec(dllexport)

-#endif

-

-// Current plugin version

-

-// use this version for old style API calls (all returned text in native encoding)

-#define PLUGIN_API_VERSION				250		

-

-// use this version for new style API calls (all returned text in UTF8 encoding on WinNT/2K/XP (native encoding on Win9x))

-#define PLUGIN_API_VERSION_WANTUTF8		((PLUGIN_API_WANTUTF8<<16)|PLUGIN_API_VERSION)

-#define PLUGIN_API_WANTUTF8				100

-

-//-----------------------------------------------------------------------------

-

-typedef struct 

-{

-	char				*moduleString;

-	char				*moduleExtensions;

-} QCDModInfo;

-

-//-----------------------------------------------------------------------------

-// Services (ops) provided by the Player

-//-----------------------------------------------------------------------------

-typedef enum 

-{									//*** below returns numeric info (*buffer not used)

-

-	opGetPlayerVersion = 0,			// high-order word = major version (eg 3.01 is 3), low-order word = minor (eg 3.01 = 1)

-	opGetParentWnd = 1,				// handle to player window

-	opGetPlayerInstance = 2,		// HINSTANCE to player executable

-

-	opGetPlayerState = 9,			// get current state of the player (returns: 1 = stopped, 2 = playing, 3 = paused, 0 = failed)

-	opGetNumTracks = 10,			// number of tracks in playlist

-	opGetCurrentIndex = 11,			// index of current track in playlist (0 based)

-	opGetNextIndex = 12,			// get index of next track to play (0 based), param1 = index start index. -1 for after current

-	opGetTrackNum = 13,				// get track number of index, param1 = index of track in playlist, -1 for current

-									//		- 'track number' is the number of the track in it's respective album, as opposed to playlist number

-									//		- the 'track number' for digital files will be 1 if the tag is not set or the file is not identified

-

-	opGetTrackLength = 14,			// get track length, param1 = index of track in playlist, -1 for current

-									//                   param2 = 0 for seconds, 1 for milliseconds

-	opGetTime = 15,					// get time on player, param1 = 0 for time displayed, 1 for track time, 2 for playlist time

-									//					   param2 = 0 for elapsed, 1 for remaining														   

-	opGetTrackState = 16,			// get whether track is marked, param1 = index of track, -1 for current

-	opGetPlaylistNum = 17,			// get playlist number of index, param1 = index of track in playlist, -1 for current

-	opGetMediaType = 18,			// get media type of track, param1 = index if track in playlist, -1 for current

-									//		- see MediaTypes below for return values

-

-	opGetAudioInfo = 19,			// get format info about currently playing track

-									//		- param1 = 0 for samplerate, 1 for bitrate, 2 for num channels

-

-	opGetOffline = 20,				// true if client is in Offline Mode

-	opGetVisTarget = 21,			// where is vis being drawn > 0 - internal to skin, 1 - external window, 2 - full screen

-	opGetAlwaysOnTop = 22,			// true if player is set to 'Always on Top'

-	opGetRepeatState = 23,			// returns: 0 - repeat off, 1 - repeat track, 2 - repeat all

-	opGetShuffleState = 27,			// returns: 0 - shuffle off, 1 - shuffle enabled

-

-	opGetTimerState = 24,			// low-order word: 0 - track ascend, 1 - playlist ascend, 2 - track descend, 3 - playlist descend

-									// hi-order word: 1 if 'show hours' is set, else 0

-

-	opGetVolume = 25,				// get master volume level (0 - 100), param1: 0 = combined, 1 = left, 2 = right

-	opSetVolume = 26,				// set master volume level, param1: vol level 0 - 100, param2: balance (-100 left, 0 center, 100 right)

-

-	opGetIndexFromPLNum = 28,		// get index from playlist number, param1 = playlist number

-

-	opGetExtensionWnd = 30,			// handle to the draggable window extension (only available on some skins), param1 = extension number (0 - 9)

-	opGetExtVisWnd = 31,			// handle to the external visual window

-	opGetMusicBrowserWnd = 32,		// handle to the music browser window 

-	opGetSkinPreviewWnd = 33,		// handle to the skin preview window 

-	opGetPropertiesWnd = 34,		// handle to the player properties window 

-	opGetExtInfoWnd = 35,			// handle to the extended information window 

-	opGetAboutWnd = 36,				// handle to the about window 

-	opGetSegmentsWnd = 37,			// handle to the segments window 

-	opGetEQPresetsWnd = 38,			// handle to the EQ presets window 

-	opGetVideoWnd = 39,				// handle to the video window 

-

-	opGetVisDimensions = 50,		// gets the width and height of visual window (param1 = -1 current vis window, 0 internal vis, 1 external vis, 2 full screen)

-									//		returns: HEIGHT in high word, WIDTH in low word 

-

-	opShowVideoWindow = 55,			// Show or Close video window (param1 = 1 for create, 2 for create and show, 0 for close)

-

-	opGetQueriesComplete = 60,		// get status on whether all tracks in playlist have been queryied for their info

-

-									// playlist manipulation

-	opDeleteIndex = 90,				// delete index from playlist (param1 = index)

-	opSelectIndex = 91,				// mark index as selected (param1 = index, param2 = 1 - set, 0 - unset)

-	opBlockIndex = 92,				// mark index as blocked (param1 = index, param2 = 1 - set, 0 - unset)

-

-	opGetMediaInfo = 99,			// get the ICddbDisc object for the index specified, param1 = index of track, -1 for current

-									//		param2 = pointer to integer that receives track value

-									//		returns: pointer to ICddbDisc object. Do not release or deallocate this pointer

-

-

-   									//*** below returns string info in buffer, param1 = size of buffer

-   									//*** returns 1 on success, 0 on failure

-

-	opGetTrackName = 100,			// get track name, param2 = index of track in playlist, -1 for current

-	opGetArtistName = 101,			// get artist name, param2 = index of track in playlist, -1 for current

-	opGetDiscName = 102,			// get disc name, param2 = index of track in playlist, -1 for current

-

-	opGetTrackFile = 103,			// file name of track in playlist, param2 = index of track in playlist, -1 for current

-	opGetSkinName = 104,			// get current skin name

-

-	opGetPluginFolder = 105,		// get current plugin folder

-	opGetPluginSettingsFile = 106,	// get settings file (plugins.ini) that plugin should save settings to

-	opGetPluginCacheFile = 107,		// get file that describes plugin validity, functions and names

-	opGetPlayerSettingsFile = 108,	// get settings file (qcd.ini) that player saves it settings to (should use for read-only)

-

-	opGetMusicFolder = 110,			// get current music folder

-	opGetPlaylistFolder = 111,		// get current playlist folder

-	opGetSkinFolder = 112,			// get current skin folder

-	opGetCDDBCacheFolder = 113,		// get current folder for CDDB cached info

-

-	opGetCurrentPlaylist = 114,		// get full pathname of playlist currently loaded 

-

-	opGetMediaID = 115,				// get media identifier, param2 = index of track in playlist, -1 for current

-									//		- for CD's it's the TOC - for anything else, right now it's 0      

-

-	opGetSupportedExtensions = 116,	// get file extensions supported by the player, param2 = 0 - get all extensions, 1 - get registered extensions

-									//		- returned extensions will be colon delimited

-

-	opGetPlaylistString = 117,		// get string for index as it appears in playlist, param2 = index

-

-   									//*** below buffer points to struct or other object

-   									//*** returns 1 on success, 0 on failure

-

-	opShowMainMenu = 120,			// Display Main QCD Menu (buffer = POINT* - location to display menu)

-	opGetMainMenu = 121,			// Returns copy of HMENU handle to QCD Menu (must use DestroyMenu on handle when complete)

-

-	opShowQuickTrack = 125,			// Display QuickTrack Menu (buffer = POINT* - location to display menu)

-	opGetQuickTrack = 126,			// Returns copy of HMENU handle to QuickTrack menu (must use DestroyMenu on handle when complete)

-									//		To use if QuickTrack item selected: PostMessage(hwndPlayer, WM_COMMAND, menu_id, 0);

-

-	opGetEQVals = 200,				// get current EQ levels/on/off (buffer = EQInfo*)

-	opSetEQVals = 201,				// set EQ levels/on/off (buffer = EQInfo*)

-

-	opGetProxyInfo = 202,			// get proxy info (buffer = ProxyInfo*), returns 0 if proxy not in use

-

-

-									//*** below returns numeric info, buffer used

-

-	opGetIndexFromFilename = 210,	// get the index of a file that exists in current playlist (buffer = full path of file),

-									//		param1 = startindex (index to start searching on)

-                                    //		returns -1 if file not in playlist

-

-

-									//*** below send information to player

-									//*** returns 1 on success, 0 on failure

-

-	opSetStatusMessage = 1000,		// display message in status area (buffer = msg buffer (null term), param1 = text flags (see below))

-

-	opSetBrowserUrl = 1001,			// set music browser URL (buffer = url (null term))

-	                                //		null url buffer - closes browser

-	                                //		param1 = 0 - normal, 1 - force open

-

-	opSetAudioInfo = 1002,			// set the current music bitrate/khz (buffer = AudioInfo*, param1 = size of AudioInfo)

-

-	opSetTrackAlbum = 1003,			// update track ablum name (buffer = album (null term), param1 = (string ptr)file name), param2 = MediaTypes

-	opSetTrackTitle = 1004,			// update track title (buffer = title (null term), param1 = (string ptr)file name), param2 = MediaTypes

-	opSetTrackArtist = 1005,		// update track artist name (buffer = artist (null term), param1 = (string ptr)file name), param2 = MediaTypes

-

-	opSetTrackExtents = 1007,		// update track TrackExtents info (buffer = &TrackExtents), param1 = (string ptr)file name)

-	opSetTrackSeekable = 1008,		// update track seekable flag (buffer = (string ptr)file name), param1 = TRUE/FALSE

-	opSetPlayNext = 1009,			// set the next index to be played (buffer = NULL, param1 = index, index = -1 unsets playnext)

-	opSetIndexFilename = 1010,		// updates the filename (or stream) that an index in the current playlist refers to, buffer = new filename, param1 = index

-

-	opSetPlaylist = 1006,			// clear playlist, add files to playlist or reset playlist with new files 

-									//		buffer = file list (each file in quotes, string null terminated) Eg; buffer="\"file1.mp3\" \"file2.mp3\"\0" - NULL to clear playlist

-									//		param1 = (string ptr)originating path (can be NULL if paths included with files) 

-									//		param2 = 1 - clear playlist flag, 2 - enqueue to top

-

-	opInsertPlaylist = 1011,		// insert tracks into playlist 

-									//		buffer = file list (each file in quotes, string null terminated) Eg; buffer="\"file1.mp3\" \"file2.mp3\"\0"

-									//		param1 = (string ptr)originating path (can be NULL if paths included with files) 

-									//		param2 = index location to insert tracks (-1 to insert at end)

-

-	opMovePlaylistTrack = 1012,		// param1 = index of track to move, param2 = destination index (move shifts tracks between param1 and param2)

-	opSwapPlaylistTracks = 1013,	// param1 = index of first track, param2 = index of second track (swap only switches indecies param1 and param2)

-

-	opCreateDiscInfo = 1020,		// returns: pointer to ICddbDisc object. Do not release or deallocate this pointer

-	opSetDiscInfo = 1021,			// buffer = ICddbDisc*, param1 = MediaInfo*, param2 = track number

-

-	opSetSeekPosition = 1100,		// seek to position during playback

-									//		buffer = NULL, param1 = position

-									//		param2 = 0 - position is in seconds, 1 - position is in milliseconds, 2 - position is in percent (use (float)param1))

-

-

-	opSetRepeatState = 1110,		// set playlist repeat state, buffer = NULL, param1 = 0 - off, 1 - repeat track, 2 - repeat playlist

-	opSetShuffleState = 1111,		// set playlist shuffle state, buffer = NULL, param1 = 0 - off, 1 - on

-

-									//*** below configures custom plugin menu items for the 'plugin menu'

-									//*** Player will call plugin's configure routine with menu value when menu item selected

-									//*** returns 1 on success, 0 on failure

-

-	opSetPluginMenuItem = 2000,		// buffer = HINSTANCE of plugin, param1 = item id, param2 = (string ptr)string to display

-									//		- set param2 = 0 to remove item id from menu

-									//		- set param1 = 0 and param2 = 0 to remove whole menu

-	opSetPluginMenuState = 2001,	// buffer = HINSTANCE of plugin, param1 = item id, param2 = menu flags (same as windows menu flags - eg: MF_CHECKED)

-

-

-									//*** below are services for using the player's filename template editor

-									//*** returns 1 on success, 0 on failure

-

-	opShowTemplateEditor = 2100,	// displays template editor dialog, param1 = (HWND)parent window, param2 = modal flag

-	opLoadTemplate = 2101,			// loads saved templates, buffer = (char*)string buf, param1 = bufsize, param2 = index of template (index < 0 for default formats, index >= 0 for user made formats)

-	opRenderTemplate = 2102,		// create string based on template, buffer = (char*)template, param1 = FormatMetaInfo*, param2 = (char*)string buffer (min 260 bytes)

-

-									//*** other services

-

-	opUTF8toUCS2 = 9000,			// convert UTF8 string to UCS2 (Unicode) string, buffer = null terminated utf8 string, param1 = (WCHAR*)result string buffer, param2 = size of result buffer

-	opUCS2toUTF8 = 9001,			// convert UCS2 (Unicode) string to UTF8 string, buffer = null terminated ucs2 string, param1 = (char*)result string buffer, param2 = size of result buffer

-

-	opSafeWait = 10000				// plugin's can use this to wait on an object without worrying about deadlocking the player.

-									// this should only be called by the thread that enters the plugin, not by any plugin-created threads

-

-} PluginServiceOp;

-

-//-----------------------------------------------------------------------------

-// Info services api provided by the Player, called by Plugin.

-//-----------------------------------------------------------------------------

-typedef long (*PluginServiceFunc)(PluginServiceOp op, void *buffer, long param1, long param2);

-

-// Use to retrieve service func for DSP plugins (or other inproc process that doesn't have access to PluginServiceFunc)

-// Eg: PluginServiceFunc Service = (PluginServiceFunc)SendMessage(hwndPlayer, WM_GETSERVICEFUNC, 0, 0);

-// Set WPARAM = PLUGIN_API_WANTUTF8 for UTF8 string parameters

-#define WM_GETSERVICEFUNC			(WM_USER + 1)

-

-//-----------------------------------------------------------------------------

-typedef struct				// for Output Plugin Write callback

-{

-	void	*data;			// pointer to valid data

-	int		bytelen;		// length of data pointed to by 'data' in bytes

-	UINT	numsamples;		// number of samples represented by 'data'

-	UINT	bps;			// bits per sample

-	UINT	nch;			// number of channels

-	UINT	srate;			// sample rate

-

-	UINT	markerstart;	// Marker position at start of data (marker is time value of data) 

-							// (set to WAVE_VIS_DATA_ONLY to not have data sent to output plugins)

-	UINT	markerend;		// Marker position at end of data (not currently used, set to 0)

-} WriteDataStruct;

-

-//-----------------------------------------------------------------------------

-typedef struct			// for GetTrackExtents Input Plugin callback

-{

-	UINT track;			// for CD's, set the track number. Otherwise set to 1.

-	UINT start;			// for CD's or media that doesn't start at the beginning 

-						// of the file, set to start position. Otherwise set to 0.

-	UINT end;			// set to end position of media.

-	UINT unitpersec;	// whatever units are being used for this media, how many

-						// of them per second. 

-						// (Note: ((end - start) / unitpersecond) = file length

-	UINT bytesize;		// size of file in bytes (if applicable, otherwise 0).

-} TrackExtents;

-

-//-----------------------------------------------------------------------------

-typedef struct			// for opSetAudioInfo service

-{		

-    long struct_size;	// sizeof(AudioInfo)

-    long level;			// MPEG level (1 for MPEG1, 2 for MPEG2, 3 for MPEG2.5, 7 for MPEGpro)

-    long layer;			// and layer (1, 2 or 3)

-    long bitrate;		// audio bitrate in bits per second

-    long frequency;		// audio freq in Hz

-    long mode;			// 0 for stereo, 1 for joint-stereo, 2 for dual-channel, 3 for mono, 4 for multi-channel

-	char text[8];		// up to eight characters to identify format (will override level and layer settings)

-} AudioInfo;

-

-//-----------------------------------------------------------------------------

-// Equalizer Info

-//-----------------------------------------------------------------------------

-typedef struct			// for coming QCD version

-{

-	long struct_size;	// sizeof(EQInfo)

-	char enabled;		

-	char preamp;		// -128 to 127, 0 is even

-	char bands[10];		// -128 to 127, 0 is even

-} EQInfo;

-

-//-----------------------------------------------------------------------------

-typedef struct

-{

-	long struct_size;	// sizeof(ProxyInfo)

-	char hostname[200];

-	long port;

-	char username[100];

-	char password[100];

-} ProxyInfo;

-

-//-----------------------------------------------------------------------------

-typedef enum			// for MediaInfo.mediaType

-{ 

-	UNKNOWN_MEDIA = 0,

-	CD_AUDIO_MEDIA = 1,

-	DIGITAL_FILE_MEDIA = 2,

-	DIGITAL_STREAM_MEDIA = 3

-} MediaTypes;

-

-//-----------------------------------------------------------------------------

-#define MAX_TOC_LEN				2048

-typedef struct

-{

-	// media descriptors

-	CHAR		mediaFile[MAX_PATH];

-	MediaTypes	mediaType;

-

-	// cd audio media info

-	CHAR		cd_mediaTOC[MAX_TOC_LEN];

-	int			cd_numTracks;

-	int			cd_hasAudio;

-

-	// operation info

-	int			op_canSeek;

-

-	// not used

-	int			reserved[4];

-

-} MediaInfo;

-

-//-----------------------------------------------------------------------------

-typedef struct

-{

-	long	struct_size;

-	LPCWSTR	title;

-	LPCWSTR	artalb;

-	LPCWSTR	album;

-	LPCWSTR	genre;

-	LPCWSTR	year;

-	LPCWSTR	tracknum;

-	LPCWSTR	filename;

-	LPCWSTR	arttrk;

-	long	reserved;

-

-} FormatMetaInfo;

-

-//-----------------------------------------------------------------------------

-// When subclassing the parent window, a plugin can watch for these messages

-// to react to events going on between plugins and player

-// DO NOT SEND THESE MESSAGES - can only watch for them

-

-// Plugin to Player Notifiers

-#define WM_PN_POSITIONUPDATE	(WM_USER + 100)	// playback progress updated

-#define WM_PN_PLAYSTARTED		(WM_USER + 101)	// playback has started

-#define WM_PN_PLAYSTOPPED		(WM_USER + 102) // playback has stopped by user

-#define WM_PN_PLAYPAUSED		(WM_USER + 103) // playback has been paused

-#define WM_PN_PLAYDONE			(WM_USER + 104) // playback has finished (track completed)

-#define WM_PN_MEDIAEJECTED		(WM_USER + 105) // a CD was ejected (CDRom drive letter= 'A' + lParam)

-#define WM_PN_MEDIAINSERTED		(WM_USER + 106) // a CD was inserted (CDRom drive letter= 'A' + lParam)

-#define WM_PN_INFOCHANGED		(WM_USER + 107) // track information was updated (lParam = (LPCSTR)medianame)

-#define WM_PN_TRACKCHANGED		(WM_USER + 109)	// current track playing has changed (relevant from CD plugin) (lParam = (LPCSTR)medianame)

-

-// Player to Plugin Notifiers

-#define WM_PN_PLAYLISTCHANGED	(WM_USER + 200) // playlist has changed in some way (add, delete, sort, shuffle, drag-n-drop, etc...)

-

-// For intercepting main menu display

-// (so you can get handle, modify, and display your own)

-#define WM_SHOWMAINMENU			(WM_USER + 20)

-

-// For intercepting skinned border window commands

-#define WM_BORDERWINDOW			(WM_USER + 26)

-// WM_BORDERWINDOW	wParam's

-#define BORDERWINDOW_NORMALSIZE			0x100000

-#define BORDERWINDOW_DOUBLESIZE			0x200000

-#define BORDERWINDOW_FULLSCREEN			0x400000

-

-// send to border window to cause resize

-// wParam = LPPOINT lpp; // point x-y is CLIENT area size of window

-#define WM_SIZEBORDERWINDOW		(WM_USER + 1)

-

-//-----------------------------------------------------------------------------

-// To shutdown player, send this command

-#define WM_SHUTDOWN				(WM_USER + 5)

-

-//-----------------------------------------------------------------------------

-// opSetStatusMessage textflags

-#define TEXT_DEFAULT		0x0		// message scrolls by in status window

-#define TEXT_TOOLTIP		0x1		// message acts as tooltip in status window

-#define TEXT_URGENT			0x2		// forces message to appear even if no status window (using msg box)

-#define TEXT_HOLD			0x4		// tooltip message stays up (no fade out)

-#define TEXT_UNICODE		0x10	// buffer contains a unicode string (multibyte string otherwise)

-

-#endif //QCDMODDEFS_H
\ No newline at end of file
diff --git a/faad2/src/plugins/QCDMp4/QCDModInput.h b/faad2/src/plugins/QCDMp4/QCDModInput.h
deleted file mode 100644
index 4150ff1..0000000
--- a/faad2/src/plugins/QCDMp4/QCDModInput.h
+++ /dev/null
@@ -1,117 +0,0 @@
-//-----------------------------------------------------------------------------

-//

-// File:	QCDModInput.h

-//

-// About:	Input plugin module interface.  This file is published with the 

-//			Input plugin SDK.

-//

-// Authors:	Written by Paul Quinn and Richard Carlson.

-//

-// Copyright:

-//

-//	QCD multimedia player application Software Development Kit Release 1.0.

-//

-//	Copyright (C) 1997-2002 Quinnware

-//

-//	This code is free.  If you redistribute it in any form, leave this notice 

-//	here.

-//

-//	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.

-//

-//-----------------------------------------------------------------------------

-

-#ifndef QCDMODINPUT_H

-#define QCDMODINPUT_H

-

-#include "QCDModDefs.h"

-

-// name of the DLL export for input plugins

-#define INPUTDLL_ENTRY_POINT		QInputModule2	// (updated plugin api version 240+)

-

-// media insert flags

-#define MEDIAINSERT_PLAY			0x1

-#define MEDIAINSERT_ADDTRACKS		0x2

-#define MEDIAINSERT_ADDSEGMENTS		0x4

-#define MEDIAINSERT_CLEARPLAYLIST	0x8

-

-// Stop will receive one of these flags (pass to output plugin's stop())

-#define STOPFLAG_FORCESTOP			0	// stop occuring due to user action or other event

-#define STOPFLAG_PLAYDONE			1	// stop occuring due to playlist completion

-

-// play flags

-#define PLAYFLAG_PLAYBACK			0x0

-#define PLAYFLAG_ENCODING			0x1

-#define PLAYFLAG_SEEKING			0x2

-

-// Wave Marker flags

-#define WAVE_VIS_DATA_ONLY			-1	// set to WaveDataStruct.markerstart in OutputWrite() call have data only go to vis 

-										// and not to output plugin

-// pause flags

-#define PAUSE_DISABLED				0	// Pause() call is to unpause playback

-#define PAUSE_ENABLED				1	// Pause() call is to pause playback

-

-//-----------------------------------------------------------------------------

-// Input Module

-//-----------------------------------------------------------------------------

-typedef struct 

-{

-	unsigned int		size;			// size of init structure

-	unsigned int		version;		// plugin structure version (set to PLUGIN_API_VERSION)

-	PluginServiceFunc	Service;		// player supplied services callback

-

-	struct

-	{

-		void (*PositionUpdate)(unsigned int position);

-		void (*PlayStopped)(const char* medianame);					// notify player of play stop

-		void (*PlayStarted)(const char* medianame);					// notify player of play start

-		void (*PlayPaused)(const char* medianame, int flags);		// notify player of play pause

-		void (*PlayDone)(const char* medianame);					// notify player when play done

-		void (*PlayTrackChanged)(const char* medianame);			// notify player when playing track changes (cd audio relevant only)

-		void (*MediaEjected)(const char* medianame);				// notify player of media eject (cd audio relevant)

-		void (*MediaInserted)(const char* medianame, int flags);	// notify player of media insert (cd audio relevant)

-

-																	// output plugin calls

-		int  (*OutputOpen)(const char* medianame, WAVEFORMATEX*);	// open output for wave data

-		int  (*OutputWrite)(WriteDataStruct*);						// send PCM audio data to output 

-																		// (blocks until write completes, thus if output is paused can 

-																		// block until unpaused)

-		int  (*OutputDrain)(int flags);								// wait for all output to complete (blocking)

-		int  (*OutputDrainCancel)(int flags);						// break a drain in progress

-		int  (*OutputFlush)(unsigned int marker);						// flush output upto marker

-		int  (*OutputStop)(int flags);								// stop output

-		int  (*OutputPause)(int flags);								// pause output

-

-		int  (*OutputSetVol)(int levelleft, int levelright, int flags);

-		int  (*OutputGetCurrentPosition)(unsigned int *position, int flags);

-

-		void *Reserved[10];

-	} toPlayer;

-

-	struct 

-	{

-		int  (*Initialize)(QCDModInfo *modInfo, int flags);			// initialize plugin

-		void (*ShutDown)(int flags);								// shutdown plugin

-

-		int  (*Play)(const char* medianame, int playfrom, int playto, int flags);	// start playing playfrom->playto

-		int  (*Stop)(const char* medianame, int flags);				// stop playing

-		int  (*Pause)(const char* medianame, int flags);			// pause playback

-		int  (*Eject)(const char* medianame, int flags);			// eject media

-		void (*SetEQ)(EQInfo*);										// update EQ settings

-

-		int  (*GetMediaSupported)(const char* medianame, MediaInfo *mediaInfo);			// does plugin support medianame (and provides info for media)

-		int  (*GetTrackExtents)(const char* medianame, TrackExtents *ext, int flags);	// get media start, end & units

-		int  (*GetCurrentPosition)(const char* medianame, long *track, long *offset);	// get playing media's position

-

-		void (*Configure)(int flags);									// launch configuration

-		void (*About)(int flags);										// launch about info

-

-		void (*SetVolume)(int levelleft, int levelright, int flags);	// level 0 - 100

-

-		void *Reserved[10];

-	} toModule;

-

-} QCDModInitIn;

-

-#endif //QCDMODINPUT_H

diff --git a/faad2/src/plugins/QCDMp4/QCDModTagEditor.h b/faad2/src/plugins/QCDMp4/QCDModTagEditor.h
deleted file mode 100644
index 13555f3..0000000
--- a/faad2/src/plugins/QCDMp4/QCDModTagEditor.h
+++ /dev/null
@@ -1,84 +0,0 @@
-//-----------------------------------------------------------------------------

-//

-// File:	QCDModTagEditor

-//

-// About:	Tag Editing plugin module interface.  This file is published with the 

-//			QCD plugin SDK.

-//

-// Authors:	Written by Paul Quinn

-//

-// Copyright:

-//

-//	QCD multimedia player application Software Development Kit Release 1.0.

-//

-//	Copyright (C) 2002 Quinnware

-//

-//	This code is free.  If you redistribute it in any form, leave this notice 

-//	here.

-//

-//	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.

-//

-//-----------------------------------------------------------------------------

-

-#ifndef QCDMODTAGEDITOR_H

-#define QCDMODTAGEDITOR_H

-

-#include "QCDModDefs.h"

-

-// name of the DLL export for output plugins

-#define TAGEDITORDLL_ENTRY_POINT	QTagEditorModule

-

-// Tag field ids

-typedef enum

-{

-	TAGFIELD_FIRSTFIELD = 0,

-

-	TAGFIELD_TITLE = 0,

-	TAGFIELD_ARTIST,

-	TAGFIELD_ALBUM, 

-	TAGFIELD_GENRE,

-	TAGFIELD_YEAR,  

-	TAGFIELD_TRACK, 

-	TAGFIELD_COMMENT,

-

-	TAGFIELD_COMPOSER,

-	TAGFIELD_CONDUCTOR,

-	TAGFIELD_ORCHESTRA,

-	TAGFIELD_YEARCOMPOSED,

-

-	TAGFIELD_ORIGARTIST,

-	TAGFIELD_LABEL, 

-	TAGFIELD_COPYRIGHT,

-	TAGFIELD_ENCODER,

-	TAGFIELD_CDDBTAGID,

-

-	TAGFIELD_FIELDCOUNT

-};

-

-//-----------------------------------------------------------------------------

-

-typedef struct 

-{

-	UINT	size;			// size of init structure

-	UINT	version;		// plugin structure version (set to PLUGIN_API_VERSION)

-

-	LPCSTR	description;

-	LPCSTR	defaultexts;

-

-	bool	(*Read)(LPCSTR filename, void* tagHandle);

-	bool	(*Write)(LPCSTR filename, void* tagHandle);

-	bool	(*Strip)(LPCSTR filename);

-

-	void	(*ShutDown)(int flags);

-

-	void	(*SetFieldA)(void* tagHandle, int fieldId, LPCSTR szNewText);

-	void	(*SetFieldW)(void* tagHandle, int fieldId, LPCWSTR szNewText);

-

-	LPCSTR	(*GetFieldA)(void* tagHandle, int fieldId);

-	LPCWSTR	(*GetFieldW)(void* tagHandle, int fieldId);

-

-} QCDModInitTag;

-

-#endif //QCDMODTAGEDITOR_H
\ No newline at end of file
diff --git a/faad2/src/plugins/QCDMp4/QCDMp4.c b/faad2/src/plugins/QCDMp4/QCDMp4.c
deleted file mode 100644
index 0709629..0000000
--- a/faad2/src/plugins/QCDMp4/QCDMp4.c
+++ /dev/null
@@ -1,2992 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: QCDMp4.c,v 1.4 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-//#define DEBUG_OUTPUT

-

-#define WIN32_LEAN_AND_MEAN

-#include <windows.h>

-#include <commctrl.h>

-#include <commdlg.h>

-#include <stdlib.h>

-#include <math.h>

-#include <faad.h>

-#include <mp4.h>

-

-#include "resource.h"

-#include "QCDInputDLL.h"

-#include "utils.h"

-#include "config.h"

-//#include "aacinfo.h"

-//#include "aac2mp4.h"

-//

-//const char *long_ext_list = "MP4\0MPEG-4 Files (*.MP4)\0M4A\0MPEG-4 Files (*.M4A)\0AAC\0AAC Files (*.AAC)\0";

-//const char *short_ext_list = "MP4\0MPEG-4 Files (*.MP4)\0M4A\0MPEG-4 Files (*.M4A)\0";

-

-static long priority_table[] = {

-    0,

-    THREAD_PRIORITY_HIGHEST,

-    THREAD_PRIORITY_ABOVE_NORMAL,

-    THREAD_PRIORITY_NORMAL,

-    THREAD_PRIORITY_BELOW_NORMAL,

-    THREAD_PRIORITY_LOWEST

-};

-static int res_id_table[] = {

-    IDC_16BITS,

-    IDC_24BITS,

-    IDC_32BITS,

-    0,

-    0,

-    /*IDC_16BITS_DITHERED*/ IDC_16BITS /* temp hack */

-};

-static int res_table[] = {

-    16,

-    24,

-    32,

-    0,

-    0,

-    16

-};

-//static char info_fn[_MAX_PATH];

-//

-//// post this to the main window at end of file (after playback has stopped)

-//#define WM_WA_AAC_EOF WM_USER+2

-

-struct seek_list

-{

-    struct seek_list *next;

-    __int64 offset;

-};

-

-typedef struct state

-{

-    /* general stuff */

-    faacDecHandle hDecoder;

-    int samplerate;

-    unsigned char channels;

-    double decode_pos_ms; // current decoding position, in milliseconds

-    int paused; // are we paused?

-    int seek_needed; // if != -1, it is the point that the decode thread should seek to, in ms.

-    char filename[_MAX_PATH];

-    int filetype; /* 0: MP4; 1: AAC */

-    int last_frame;

-    __int64 last_offset;

-

-    /* MP4 stuff */

-    MP4FileHandle mp4file;

-    int mp4track;

-    MP4SampleId numSamples;

-    MP4SampleId sampleId;

-

-    /* AAC stuff */

-    FILE *aacfile;

-    long m_aac_bytes_into_buffer;

-    long m_aac_bytes_consumed;

-    __int64 m_file_offset;

-    unsigned char *m_aac_buffer;

-    int m_at_eof;

-    double cur_pos_sec;

-    int m_header_type;

-    struct seek_list *m_head;

-    struct seek_list *m_tail;

-    unsigned long m_length;

-

-    /* for gapless decoding */

-    unsigned int useAacLength;

-    unsigned int framesize;

-    unsigned int initial;

-    unsigned long timescale;

-} state;

-

-static state mp4state;

-

-//static In_Module module; // the output module (declared near the bottom of this file)

-struct {

-	HINSTANCE		hDllInstance;

-	HWND			hMainWindow;

-	QCDModInitIn	QCDCallbacks;

-} module;

-AudioInfo		ai;

-

-static int killPlayThread;

-static int PlayThreadAlive = 0; // 1=play thread still running

-HANDLE play_thread_handle = INVALID_HANDLE_VALUE; // the handle to the decode thread

-

-/* Function definitions */

-void *decode_aac_frame(state *st, faacDecFrameInfo *frameInfo);

-DWORD WINAPI MP4PlayThread(void *b); // the decode thread procedure

-DWORD WINAPI AACPlayThread(void *b); // the decode thread procedure

-

-

-//typedef struct tag

-//{

-//    char *item;

-//    char *value;

-//} tag;

-//

-//typedef struct medialib_tags

-//{

-//    struct tag *tags;

-//    unsigned int count;

-//} medialib_tags;

-//

-//int tag_add_field(medialib_tags *tags, const char *item, const char *value)

-//{

-//    void *backup = (void *)tags->tags;

-//

-//    if (!item || (item && !*item) || !value) return 0;

-//

-//    tags->tags = (struct tag *)realloc(tags->tags, (tags->count+1) * sizeof(tag));

-//    if (!tags->tags) {

-//        if (backup) free(backup);

-//        return 0;

-//    }

-//    else

-//    {

-//        int i_len = strlen(item);

-//        int v_len = strlen(value);

-//

-//        tags->tags[tags->count].item = (char *)malloc(i_len+1);

-//        tags->tags[tags->count].value = (char *)malloc(v_len+1);

-//

-//        if (!tags->tags[tags->count].item || !tags->tags[tags->count].value)

-//        {

-//            if (!tags->tags[tags->count].item) free (tags->tags[tags->count].item);

-//            if (!tags->tags[tags->count].value) free (tags->tags[tags->count].value);

-//            tags->tags[tags->count].item = NULL;

-//            tags->tags[tags->count].value = NULL;

-//            return 0;

-//        }

-//

-//        memcpy(tags->tags[tags->count].item, item, i_len);

-//        memcpy(tags->tags[tags->count].value, value, v_len);

-//        tags->tags[tags->count].item[i_len] = '\0';

-//        tags->tags[tags->count].value[v_len] = '\0';

-//

-//        tags->count++;

-//        return 1;

-//    }

-//}

-//

-//int tag_set_field(medialib_tags *tags, const char *item, const char *value)

-//{

-//    unsigned int i;

-//

-//    if (!item || (item && !*item) || !value) return 0;

-//

-//    for (i = 0; i < tags->count; i++)

-//    {

-//        if (!stricmp(tags->tags[i].item, item))

-//        {

-//            void *backup = (void *)tags->tags[i].value;

-//            int v_len = strlen(value);

-//

-//            tags->tags[i].value = (char *)realloc(tags->tags[i].value, v_len+1);

-//            if (!tags->tags[i].value)

-//            {

-//                if (backup) free(backup);

-//                return 0;

-//            }

-//

-//            memcpy(tags->tags[i].value, value, v_len);

-//            tags->tags[i].value[v_len] = '\0';

-//

-//            return 1;

-//        }

-//    }

-//

-//    return tag_add_field(tags, item, value);

-//}

-//

-//int tag_delete(medialib_tags *tags)

-//{

-//    unsigned int i;

-//

-//    for (i = 0; i < tags->count; i++)

-//    {

-//        if (tags->tags[i].item) free(tags->tags[i].item);

-//        if (tags->tags[i].value) free(tags->tags[i].value);

-//    }

-//

-//    if (tags->tags) free(tags->tags);

-//

-//    tags->tags = NULL;

-//    tags->count = 0;

-//}

-//

-//int ReadMP4Tag(MP4FileHandle file, medialib_tags *tags)

-//{

-//    unsigned __int32 valueSize;

-//    unsigned __int8 *pValue;

-//    char *pName;

-//    unsigned int i = 0;

-//

-//    do {

-//        pName = 0;

-//        pValue = 0;

-//        valueSize = 0;

-//

-//        MP4GetMetadataByIndex(file, i, (const char **)&pName, &pValue, &valueSize);

-//

-//        if (valueSize > 0)

-//        {

-//            char *val = (char *)malloc(valueSize+1);

-//            if (!val) return 0;

-//            memcpy(val, pValue, valueSize);

-//            val[valueSize] = '\0';

-//

-//            if (pName[0] == '\xa9')

-//            {

-//                if (memcmp(pName, "©nam", 4) == 0)

-//                {

-//                    tag_add_field(tags, "title", val);

-//                } else if (memcmp(pName, "©ART", 4) == 0) {

-//                    tag_add_field(tags, "artist", val);

-//                } else if (memcmp(pName, "©wrt", 4) == 0) {

-//                    tag_add_field(tags, "writer", val);

-//                } else if (memcmp(pName, "©alb", 4) == 0) {

-//                    tag_add_field(tags, "album", val);

-//                } else if (memcmp(pName, "©day", 4) == 0) {

-//                    tag_add_field(tags, "date", val);

-//                } else if (memcmp(pName, "©too", 4) == 0) {

-//                    tag_add_field(tags, "tool", val);

-//                } else if (memcmp(pName, "©cmt", 4) == 0) {

-//                    tag_add_field(tags, "comment", val);

-//                } else if (memcmp(pName, "©gen", 4) == 0) {

-//                    tag_add_field(tags, "genre", val);

-//                } else {

-//                    tag_add_field(tags, pName, val);

-//                }

-//            } else if (memcmp(pName, "gnre", 4) == 0) {

-//                char *t=0;

-//                if (MP4GetMetadataGenre(file, &t))

-//                {

-//                    tag_add_field(tags, "genre", t);

-//                }

-//            } else if (memcmp(pName, "trkn", 4) == 0) {

-//                unsigned __int16 trkn = 0, tot = 0;

-//                char t[200];

-//                if (MP4GetMetadataTrack(file, &trkn, &tot))

-//                {

-//                    if (tot > 0)

-//                        wsprintf(t, "%d/%d", trkn, tot);

-//                    else

-//                        wsprintf(t, "%d", trkn);

-//                    tag_add_field(tags, "tracknumber", t);

-//                }

-//            } else if (memcmp(pName, "disk", 4) == 0) {

-//                unsigned __int16 disk = 0, tot = 0;

-//                char t[200];

-//                if (MP4GetMetadataDisk(file, &disk, &tot))

-//                {

-//                    if (tot > 0)

-//                        wsprintf(t, "%d/%d", disk, tot);

-//                    else

-//                        wsprintf(t, "%d", disk);

-//                    tag_add_field(tags, "disc", t);

-//                }

-//            } else if (memcmp(pName, "cpil", 4) == 0) {

-//                unsigned __int8 cpil = 0;

-//                char t[200];

-//                if (MP4GetMetadataCompilation(file, &cpil))

-//                {

-//                    wsprintf(t, "%d", cpil);

-//                    tag_add_field(tags, "compilation", t);

-//                }

-//            } else if (memcmp(pName, "tmpo", 4) == 0) {

-//                unsigned __int16 tempo = 0;

-//                char t[200];

-//                if (MP4GetMetadataTempo(file, &tempo))

-//                {

-//                    wsprintf(t, "%d BPM", tempo);

-//                    tag_add_field(tags, "tempo", t);

-//                }

-//            } else if (memcmp(pName, "NDFL", 4) == 0) {

-//                /* Removed */

-//            } else {

-//                tag_add_field(tags, pName, val);

-//            }

-//

-//            free(val);

-//        }

-//

-//        i++;

-//    } while (valueSize > 0);

-//

-//    return 1;

-//}

-//

-//int mp4_set_metadata(MP4FileHandle file, const char *item, const char *val)

-//{

-//    if (!item || (item && !*item) || !val || (val && !*val)) return 0;

-//

-//    if (!stricmp(item, "track") || !stricmp(item, "tracknumber"))

-//    {

-//        unsigned __int16 trkn, tot;

-//        int t1 = 0, t2 = 0;

-//        sscanf(val, "%d/%d", &t1, &t2);

-//        trkn = t1, tot = t2;

-//        if (!trkn) return 1;

-//        if (MP4SetMetadataTrack(file, trkn, tot)) return 1;

-//    }

-//    else if (!stricmp(item, "disc") || !stricmp(item, "disknumber"))

-//    {

-//        unsigned __int16 disk, tot;

-//        int t1 = 0, t2 = 0;

-//        sscanf(val, "%d/%d", &t1, &t2);

-//        disk = t1, tot = t2;

-//        if (!disk) return 1;

-//        if (MP4SetMetadataDisk(file, disk, tot)) return 1;

-//    }

-//    else if (!stricmp(item, "compilation"))

-//    {

-//        unsigned __int8 cpil = atoi(val);

-//        if (!cpil) return 1;

-//        if (MP4SetMetadataCompilation(file, cpil)) return 1;

-//    }

-//    else if (!stricmp(item, "tempo"))

-//    {

-//        unsigned __int16 tempo = atoi(val);

-//        if (!tempo) return 1;

-//        if (MP4SetMetadataTempo(file, tempo)) return 1;

-//    }

-//    else if (!stricmp(item, "artist"))

-//    {

-//        if (MP4SetMetadataArtist(file, val)) return 1;

-//    }

-//    else if (!stricmp(item, "writer"))

-//    {

-//        if (MP4SetMetadataWriter(file, val)) return 1;

-//    }

-//    else if (!stricmp(item, "title"))

-//    {

-//        if (MP4SetMetadataName(file, val)) return 1;

-//    }

-//    else if (!stricmp(item, "album"))

-//    {

-//        if (MP4SetMetadataAlbum(file, val)) return 1;

-//    }

-//    else if (!stricmp(item, "date") || !stricmp(item, "year"))

-//    {

-//        if (MP4SetMetadataYear(file, val)) return 1;

-//    }

-//    else if (!stricmp(item, "comment"))

-//    {

-//        if (MP4SetMetadataComment(file, val)) return 1;

-//    }

-//    else if (!stricmp(item, "genre"))

-//    {

-//        if (MP4SetMetadataGenre(file, val)) return 1;

-//    }

-//    else if (!stricmp(item, "tool"))

-//    {

-//        if (MP4SetMetadataTool(file, val)) return 1;

-//    }

-//    else

-//    {

-//        if (MP4SetMetadataFreeForm(file, (char *)item, (u_int8_t *)val, (u_int32_t)strlen(val))) return 1;

-//    }

-//

-//    return 0;

-//}

-//

-//int WriteMP4Tag(MP4FileHandle file, const medialib_tags *tags)

-//{

-//    unsigned int i;

-//

-//    for (i = 0; i < tags->count; i++)

-//    {

-//        const char *item = tags->tags[i].item;

-//        const char *value = tags->tags[i].value;

-//

-//        if (value && *value)

-//        {

-//            mp4_set_metadata(file, item, value);

-//        }

-//    }

-//}

-

-

-#ifdef DEBUG_OUTPUT

-void in_mp4_DebugOutput(char *message)

-{

-    char s[1024];

-

-    sprintf(s, "in_mp4: %s: %s", mp4state.filename, message);

-    OutputDebugString(s);

-}

-#endif

-

-int file_length(FILE *f)

-{

-    long end = 0;

-    long cur = ftell(f);

-    fseek(f, 0, SEEK_END);

-    end = ftell(f);

-    fseek(f, cur, SEEK_SET);

-

-    return end;

-}

-

-static void show_error(HWND hwnd, char *message, ...)

-{

-    if (m_show_errors)

-        MessageBox(hwnd, message, "Error", MB_OK);

-}

-

-static void config_init()

-{

-    //char *p=INI_FILE;

-    //GetModuleFileName(NULL,INI_FILE,_MAX_PATH);

-    //while (*p) p++;

-    //while (p >= INI_FILE && *p != '.') p--;

-    //strcpy(p+1,"ini");

-	module.QCDCallbacks.Service(opGetPluginSettingsFile, INI_FILE, MAX_PATH, 0);

-}

-

-void config_read()

-{

-    char priority[10];

-    char resolution[10];

-    char show_errors[10];

-    char use_for_aac[10];

-    char downmix[10];

-    char vbr_display[10];

-

-    config_init();

-

-    strcpy(show_errors, "1");

-    strcpy(priority, "3");

-    strcpy(resolution, "0");

-    strcpy(use_for_aac, "1");

-    strcpy(downmix, "0");

-    strcpy(vbr_display, "1");

-    //strcpy(titleformat, "%7");

-

-    RS(priority);

-    RS(resolution);

-    RS(show_errors);

-    RS(use_for_aac);

-    RS(downmix);

-    RS(vbr_display);

-    //RS(titleformat);

-

-    m_priority = atoi(priority);

-    m_resolution = atoi(resolution);

-    m_show_errors = atoi(show_errors);

-    m_use_for_aac = atoi(use_for_aac);

-    m_downmix = atoi(downmix);

-    m_vbr_display = atoi(vbr_display);

-}

-

-void config_write()

-{

-    char priority[10];

-    char resolution[10];

-    char show_errors[10];

-    char use_for_aac[10];

-    char downmix[10];

-    char vbr_display[10];

-

-    itoa(m_priority, priority, 10);

-    itoa(m_resolution, resolution, 10);

-    itoa(m_show_errors, show_errors, 10);

-    itoa(m_use_for_aac, use_for_aac, 10);

-    itoa(m_downmix, downmix, 10);

-    itoa(m_vbr_display, vbr_display, 10);

-

-    WS(priority);

-    WS(resolution);

-    WS(show_errors);

-    WS(use_for_aac);

-    WS(downmix);

-    WS(vbr_display);

-    //WS(titleformat);

-}

-

-int Initialize(QCDModInfo *ModInfo, int flags)

-{

-	ModInfo->moduleString = "MP4 Plug-in v" FAAD2_VERSION;

-

-	module.hMainWindow = (HWND)module.QCDCallbacks.Service(opGetParentWnd, 0, 0, 0);

-

-	// read config from config file

-    config_read();

-

-	ModInfo->moduleExtensions = !m_use_for_aac ? "MP4:M4A" : "MP4:M4A:AAC";

-

-	// return TRUE for successful initialization

-	return 1;

-}

-

-//----------------------------------------------------------------------------

-

-void ShutDown(int flags) 

-{

-	Stop(mp4state.filename, STOPFLAG_FORCESTOP);

-}

-

-///* Convert UNICODE to UTF-8

-//   Return number of bytes written */

-//int unicodeToUtf8 ( const WCHAR* lpWideCharStr, char* lpMultiByteStr, int cwcChars )

-//{

-//    const unsigned short*   pwc = (unsigned short *)lpWideCharStr;

-//    unsigned char*          pmb = (unsigned char  *)lpMultiByteStr;

-//    const unsigned short*   pwce;

-//    size_t  cBytes = 0;

-//

-//    if ( cwcChars >= 0 ) {

-//        pwce = pwc + cwcChars;

-//    } else {

-//        pwce = (unsigned short *)((size_t)-1);

-//    }

-//

-//    while ( pwc < pwce ) {

-//        unsigned short  wc = *pwc++;

-//

-//        if ( wc < 0x00000080 ) {

-//            *pmb++ = (char)wc;

-//            cBytes++;

-//        } else

-//        if ( wc < 0x00000800 ) {

-//            *pmb++ = (char)(0xC0 | ((wc >>  6) & 0x1F));

-//            cBytes++;

-//            *pmb++ = (char)(0x80 |  (wc        & 0x3F));

-//            cBytes++;

-//        } else

-//        if ( wc < 0x00010000 ) {

-//            *pmb++ = (char)(0xE0 | ((wc >> 12) & 0x0F));

-//            cBytes++;

-//            *pmb++ = (char)(0x80 | ((wc >>  6) & 0x3F));

-//            cBytes++;

-//            *pmb++ = (char)(0x80 |  (wc        & 0x3F));

-//            cBytes++;

-//        }

-//        if ( wc == L'\0' )

-//            return cBytes;

-//    }

-//

-//    return cBytes;

-//}

-//

-///* Convert UTF-8 coded string to UNICODE

-//   Return number of characters converted */

-//int utf8ToUnicode ( const char* lpMultiByteStr, WCHAR* lpWideCharStr, int cmbChars )

-//{

-//    const unsigned char*    pmb = (unsigned char  *)lpMultiByteStr;

-//    unsigned short*         pwc = (unsigned short *)lpWideCharStr;

-//    const unsigned char*    pmbe;

-//    size_t  cwChars = 0;

-//

-//    if ( cmbChars >= 0 ) {

-//        pmbe = pmb + cmbChars;

-//    } else {

-//        pmbe = (unsigned char *)((size_t)-1);

-//    }

-//

-//    while ( pmb < pmbe ) {

-//        char            mb = *pmb++;

-//        unsigned int    cc = 0;

-//        unsigned int    wc;

-//

-//        while ( (cc < 7) && (mb & (1 << (7 - cc)))) {

-//            cc++;

-//        }

-//

-//        if ( cc == 1 || cc > 6 )                    // illegal character combination for UTF-8

-//            continue;

-//

-//        if ( cc == 0 ) {

-//            wc = mb;

-//        } else {

-//            wc = (mb & ((1 << (7 - cc)) - 1)) << ((cc - 1) * 6);

-//            while ( --cc > 0 ) {

-//                if ( pmb == pmbe )                  // reached end of the buffer

-//                    return cwChars;

-//                mb = *pmb++;

-//                if ( ((mb >> 6) & 0x03) != 2 )      // not part of multibyte character

-//                    return cwChars;

-//                wc |= (mb & 0x3F) << ((cc - 1) * 6);

-//            }

-//        }

-//

-//        if ( wc & 0xFFFF0000 )

-//            wc = L'?';

-//        *pwc++ = wc;

-//        cwChars++;

-//        if ( wc == L'\0' )

-//            return cwChars;

-//    }

-//

-//    return cwChars;

-//}

-//

-///* convert Windows ANSI to UTF-8 */

-//int ConvertANSIToUTF8 ( const char* ansi, char* utf8 )

-//{

-//    WCHAR*  wszValue;          // Unicode value

-//    size_t  ansi_len;

-//    size_t  len;

-//

-//    *utf8 = '\0';

-//    if ( ansi == NULL )

-//        return 0;

-//

-//    ansi_len = strlen ( ansi );

-//

-//    if ( (wszValue = (WCHAR *)malloc ( (ansi_len + 1) * 2 )) == NULL )

-//        return 0;

-//

-//    /* Convert ANSI value to Unicode */

-//    if ( (len = MultiByteToWideChar ( CP_ACP, 0, ansi, ansi_len + 1, wszValue, (ansi_len + 1) * 2 )) == 0 ) {

-//        free ( wszValue );

-//        return 0;

-//    }

-//

-//    /* Convert Unicode value to UTF-8 */

-//    if ( (len = unicodeToUtf8 ( wszValue, utf8, -1 )) == 0 ) {

-//        free ( wszValue );

-//        return 0;

-//    }

-//

-//    free ( wszValue );

-//

-//    return len-1;

-//}

-//

-///* convert UTF-8 to Windows ANSI */

-//int ConvertUTF8ToANSI ( const char* utf8, char* ansi )

-//{

-//    WCHAR*  wszValue;          // Unicode value

-//    size_t  utf8_len;

-//    size_t  len;

-//

-//    *ansi = '\0';

-//    if ( utf8 == NULL )

-//        return 0;

-//

-//    utf8_len = strlen ( utf8 );

-//

-//    if ( (wszValue = (WCHAR *)malloc ( (utf8_len + 1) * 2 )) == NULL )

-//        return 0;

-//

-//    /* Convert UTF-8 value to Unicode */

-//    if ( (len = utf8ToUnicode ( utf8, wszValue, utf8_len + 1 )) == 0 ) {

-//        free ( wszValue );

-//        return 0;

-//    }

-//

-//    /* Convert Unicode value to ANSI */

-//    if ( (len = WideCharToMultiByte ( CP_ACP, 0, wszValue, -1, ansi, (utf8_len + 1) * 2, NULL, NULL )) == 0 ) {

-//        free ( wszValue );

-//        return 0;

-//    }

-//

-//    free ( wszValue );

-//

-//    return len-1;

-//}

-//

-//BOOL uSetDlgItemText(HWND hwnd, int id, const char *str)

-//{

-//    char *temp;

-//    size_t len;

-//    int r;

-//

-//    if (!str) return FALSE;

-//    if (!*str) return TRUE;

-//    len = strlen(str);

-//    temp = malloc(len+1);

-//    if (!temp) return FALSE;

-//    r = ConvertUTF8ToANSI(str, temp);

-//    if (r > 0)

-//        SetDlgItemText(hwnd, id, temp);

-//    free(temp);

-//

-//    return r>0 ? TRUE : FALSE;

-//}

-//

-//UINT uGetDlgItemText(HWND hwnd, int id, char *str, int max)

-//{

-//    char *temp, *utf8;

-//    int len;

-//    HWND w;

-//

-//    if (!str || !max) return 0;

-//    *str = '\0';

-//    w = GetDlgItem(hwnd, id);

-//    len = GetWindowTextLength(w);

-//    temp = malloc(len+1);

-//    if (!temp) return 0;

-//    utf8 = malloc((len+1)*4);

-//    if (!utf8)

-//    {

-//        free(temp);

-//        return 0;

-//    }

-//

-//    len = GetWindowText(w, temp, len+1);

-//    if (len > 0)

-//    {

-//        len = ConvertANSIToUTF8(temp, utf8);

-//        if (len > max-1)

-//        {

-//            len = max-1;

-//            utf8[max] = '\0';

-//        }

-//        memcpy(str, utf8, len+1);

-//    }

-//

-//    free(temp);

-//    free(utf8);

-//

-//    return len;

-//}

-//

-//BOOL CALLBACK mp4_info_dialog_proc(HWND hwndDlg, UINT message,

-//                                   WPARAM wParam, LPARAM lParam)

-//{

-//    char *file_info;

-//    MP4FileHandle file;

-//    char *pVal, dummy1[1024], dummy3;

-//    short dummy, dummy2;

-//    char temp[1024];

-//    struct medialib_tags tags;

-//    tags.count = 0;

-//    tags.tags = NULL;

-//

-//#ifdef DEBUG_OUTPUT

-//    in_mp4_DebugOutput("mp4_info_dialog_proc");

-//#endif

-//

-//    switch (message) {

-//    case WM_INITDIALOG:

-//        EnableWindow(GetDlgItem(hwndDlg,IDC_CONVERT), FALSE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_CONVERT), SW_HIDE);

-//        EnableWindow(GetDlgItem(hwndDlg,IDC_CONVERT1), FALSE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_CONVERT1), SW_HIDE);

-//        EnableWindow(GetDlgItem(hwndDlg,IDC_CONVERT2), FALSE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_CONVERT2), SW_HIDE);

-//

-//        file = MP4Read(info_fn, 0);

-//

-//        if (file == MP4_INVALID_FILE_HANDLE)

-//            return FALSE;

-//

-//        file_info = MP4Info(file, MP4_INVALID_TRACK_ID);

-//        SetDlgItemText(hwndDlg, IDC_INFOTEXT, file_info);

-//        free(file_info);

-//

-//        /* get Metadata */

-//

-//        pVal = NULL;

-//        if (MP4GetMetadataName(file, &pVal))

-//            uSetDlgItemText(hwndDlg,IDC_METANAME, pVal);

-//

-//        pVal = NULL;

-//        if (MP4GetMetadataArtist(file, &pVal))

-//            uSetDlgItemText(hwndDlg,IDC_METAARTIST, pVal);

-//

-//        pVal = NULL;

-//        if (MP4GetMetadataWriter(file, &pVal))

-//            uSetDlgItemText(hwndDlg,IDC_METAWRITER, pVal);

-//

-//        pVal = NULL;

-//        if (MP4GetMetadataComment(file, &pVal))

-//            uSetDlgItemText(hwndDlg,IDC_METACOMMENTS, pVal);

-//

-//        pVal = NULL;

-//        if (MP4GetMetadataAlbum(file, &pVal))

-//            uSetDlgItemText(hwndDlg,IDC_METAALBUM, pVal);

-//

-//        pVal = NULL;

-//        if (MP4GetMetadataGenre(file, &pVal))

-//            uSetDlgItemText(hwndDlg,IDC_METAGENRE, pVal);

-//

-//        dummy = 0;

-//        MP4GetMetadataTempo(file, &dummy);

-//        if (dummy)

-//        {

-//            wsprintf(dummy1, "%d", dummy);

-//            SetDlgItemText(hwndDlg,IDC_METATEMPO, dummy1);

-//        }

-//

-//        dummy = 0; dummy2 = 0;

-//        MP4GetMetadataTrack(file, &dummy, &dummy2);

-//        if (dummy)

-//        {

-//            wsprintf(dummy1, "%d", dummy);

-//            SetDlgItemText(hwndDlg,IDC_METATRACK1, dummy1);

-//        }

-//        if (dummy2)

-//        {

-//            wsprintf(dummy1, "%d", dummy2);

-//            SetDlgItemText(hwndDlg,IDC_METATRACK2, dummy1);

-//        }

-//

-//        dummy = 0; dummy2 = 0;

-//        MP4GetMetadataDisk(file, &dummy, &dummy2);

-//        if (dummy)

-//        {

-//            wsprintf(dummy1, "%d", dummy);

-//            SetDlgItemText(hwndDlg,IDC_METADISK1, dummy1);

-//        }

-//        if (dummy2)

-//        {

-//            wsprintf(dummy1, "%d", dummy2);

-//            SetDlgItemText(hwndDlg,IDC_METADISK2, dummy1);

-//        }

-//

-//        pVal = NULL;

-//        if (MP4GetMetadataYear(file, &pVal))

-//            uSetDlgItemText(hwndDlg,IDC_METAYEAR, pVal);

-//

-//        dummy3 = 0;

-//        MP4GetMetadataCompilation(file, &dummy3);

-//        if (dummy3)

-//            SendMessage(GetDlgItem(hwndDlg, IDC_METACOMPILATION), BM_SETCHECK, BST_CHECKED, 0);

-//

-//        /* ! Metadata */

-//

-//        MP4Close(file);

-//

-//        return TRUE;

-//

-//    case WM_COMMAND:

-//        switch (LOWORD(wParam)) {

-//        case IDCANCEL:

-//            EndDialog(hwndDlg, wParam);

-//            return TRUE;

-//        case IDOK:

-//

-//            /* save Metadata changes */

-//

-//            tag_delete(&tags);

-//            file = MP4Read(info_fn, 0);

-//            if (file != MP4_INVALID_FILE_HANDLE)

-//            {

-//                ReadMP4Tag(file, &tags);

-//                MP4Close(file);

-//

-//                file = MP4Modify(info_fn, 0, 0);

-//                if (file != MP4_INVALID_FILE_HANDLE)

-//                {

-//                    MP4MetadataDelete(file);

-//                    MP4Close(file);

-//                }

-//            }

-//

-//            file = MP4Modify(info_fn, 0, 0);

-//            if (file == MP4_INVALID_FILE_HANDLE)

-//            {

-//                tag_delete(&tags);

-//                EndDialog(hwndDlg, wParam);

-//                return FALSE;

-//            }

-//

-//            uGetDlgItemText(hwndDlg, IDC_METANAME, dummy1, 1024);

-//            tag_set_field(&tags, "title", dummy1);

-//

-//            uGetDlgItemText(hwndDlg, IDC_METAWRITER, dummy1, 1024);

-//            tag_set_field(&tags, "writer", dummy1);

-//

-//            uGetDlgItemText(hwndDlg, IDC_METAARTIST, dummy1, 1024);

-//            tag_set_field(&tags, "artist", dummy1);

-//

-//            uGetDlgItemText(hwndDlg, IDC_METAALBUM, dummy1, 1024);

-//            tag_set_field(&tags, "album", dummy1);

-//

-//            uGetDlgItemText(hwndDlg, IDC_METACOMMENTS, dummy1, 1024);

-//            tag_set_field(&tags, "comment", dummy1);

-//

-//            uGetDlgItemText(hwndDlg, IDC_METAGENRE, dummy1, 1024);

-//            tag_set_field(&tags, "genre", dummy1);

-//

-//            uGetDlgItemText(hwndDlg, IDC_METAYEAR, dummy1, 1024);

-//            tag_set_field(&tags, "year", dummy1);

-//

-//            GetDlgItemText(hwndDlg, IDC_METATRACK1, dummy1, 1024);

-//            dummy = atoi(dummy1);

-//            GetDlgItemText(hwndDlg, IDC_METATRACK2, dummy1, 1024);

-//            dummy2 = atoi(dummy1);

-//            wsprintf(temp, "%d/%d", dummy, dummy2);

-//            tag_set_field(&tags, "track", temp);

-//

-//            GetDlgItemText(hwndDlg, IDC_METADISK1, dummy1, 1024);

-//            dummy = atoi(dummy1);

-//            GetDlgItemText(hwndDlg, IDC_METADISK2, dummy1, 1024);

-//            dummy2 = atoi(dummy1);

-//            wsprintf(temp, "%d/%d", dummy, dummy2);

-//            tag_set_field(&tags, "disc", temp);

-//

-//            GetDlgItemText(hwndDlg, IDC_METATEMPO, dummy1, 1024);

-//            tag_set_field(&tags, "tempo", dummy1);

-//

-//            dummy3 = SendMessage(GetDlgItem(hwndDlg, IDC_METACOMPILATION), BM_GETCHECK, 0, 0);

-//            tag_set_field(&tags, "compilation", (dummy3 ? "1" : "0"));

-//

-//            WriteMP4Tag(file, &tags);

-//

-//            MP4Close(file);

-//

-//            MP4Optimize(info_fn, NULL, 0);

-//            /* ! */

-//

-//            EndDialog(hwndDlg, wParam);

-//            return TRUE;

-//        }

-//    }

-//    return FALSE;

-//}

-//

-///* returns the name of the object type */

-//char *get_ot_string(int ot)

-//{

-//    switch (ot)

-//    {

-//    case 0:

-//        return "Main";

-//    case 1:

-//        return "LC";

-//    case 2:

-//        return "SSR";

-//    case 3:

-//        return "LTP";

-//    }

-//    return NULL;

-//}

-//

-//BOOL CALLBACK aac_info_dialog_proc(HWND hwndDlg, UINT message,

-//                                   WPARAM wParam, LPARAM lParam)

-//{

-//    faadAACInfo aacInfo;

-//    char *info_text, *header_string;

-//

-//#ifdef DEBUG_OUTPUT

-//    in_mp4_DebugOutput("aac_info_dialog_proc");

-//#endif

-//

-//    switch (message) {

-//    case WM_INITDIALOG:

-//        EnableWindow(GetDlgItem(hwndDlg,IDC_USERDATA), FALSE) ;

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_USERDATA), SW_HIDE);

-//

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC1), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC2), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC3), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC4), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC5), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC6), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC7), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC8), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC9), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC10), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC11), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC12), SW_HIDE);

-//

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METANAME), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METAARTIST), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METAWRITER), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METACOMMENTS), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METAALBUM), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METAGENRE), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METATEMPO), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METATRACK1), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METATRACK2), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METADISK1), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METADISK2), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METAYEAR), SW_HIDE);

-//        ShowWindow(GetDlgItem(hwndDlg,IDC_METACOMPILATION), SW_HIDE);

-//

-//        info_text = malloc(1024*sizeof(char));

-//

-//        get_AAC_format(info_fn, &aacInfo);

-//

-//        switch (aacInfo.headertype)

-//        {

-//        case 0: /* RAW */

-//            header_string = " RAW";

-//            break;

-//        case 1: /* ADIF */

-//            header_string = " ADIF";

-//            break;

-//        case 2: /* ADTS */

-//            header_string = " ADTS";

-//            break;

-//        }

-//

-//        sprintf(info_text, "%s AAC %s%s, %d sec, %d kbps, %d Hz",

-//            (aacInfo.version==2)?"MPEG-2":"MPEG-4", get_ot_string(aacInfo.object_type),

-//            header_string,

-//            (int)((float)aacInfo.length/1000.0), (int)((float)aacInfo.bitrate/1000.0+0.5),

-//            aacInfo.sampling_rate);

-//

-//        SetDlgItemText(hwndDlg, IDC_INFOTEXT, info_text);

-//

-//        free(info_text);

-//

-//        return TRUE;

-//

-//    case WM_COMMAND:

-//        switch (LOWORD(wParam))

-//        {

-//        case IDC_CONVERT:

-//            {

-//                char mp4FileName[256];

-//                char *extension;

-//                OPENFILENAME ofn;

-//

-//                lstrcpy(mp4FileName, info_fn);

-//                extension = strrchr(mp4FileName, '.');

-//                lstrcpy(extension, ".mp4");

-//

-//                memset(&ofn, 0, sizeof(OPENFILENAME));

-//                ofn.lStructSize = sizeof(OPENFILENAME);

-//                ofn.hwndOwner = hwndDlg;

-//                ofn.hInstance = module.hDllInstance;

-//                ofn.nMaxFileTitle = 31;

-//                ofn.lpstrFile = (LPSTR)mp4FileName;

-//                ofn.nMaxFile = _MAX_PATH;

-//                ofn.lpstrFilter = "MP4 Files (*.mp4)\0*.mp4\0";

-//                ofn.lpstrDefExt = "mp4";

-//                ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY;

-//                ofn.lpstrTitle = "Select Output File";

-//

-//                if (GetSaveFileName(&ofn))

-//                {

-//                    if (covert_aac_to_mp4(info_fn, mp4FileName))

-//                    {

-//                        MessageBox(hwndDlg, "An error occured while converting AAC to MP4!", "An error occured!", MB_OK);

-//                        return FALSE;

-//                    }

-//                }

-//                return TRUE;

-//            }

-//        case IDCANCEL:

-//        case IDOK:

-//            EndDialog(hwndDlg, wParam);

-//            return TRUE;

-//        }

-//    }

-//    return FALSE;

-//}

-//

-//int infoDlg(char *fn, HWND hwndParent)

-//{

-//    if(!stricmp(fn + strlen(fn) - 3,"AAC"))

-//    {

-//        lstrcpy(info_fn, fn);

-//

-//        DialogBox(module.hDllInstance, MAKEINTRESOURCE(IDD_INFO),

-//            hwndParent, aac_info_dialog_proc);

-//    } else {

-//        lstrcpy(info_fn, fn);

-//

-//        DialogBox(module.hDllInstance, MAKEINTRESOURCE(IDD_INFO),

-//            hwndParent, mp4_info_dialog_proc);

-//    }

-//

-//    return 0;

-//}

-//

-///* Get the title from the file */

-//void ConstructTitle(MP4FileHandle file, char *filename, char *title, char *format)

-//{

-//    char temp[4096];

-//    int some_info = 0;

-//    char *in = format;

-//    char *out = temp;//title;

-//    char *bound = out + sizeof(temp) - 256; //out + (MAX_PATH - 10 - 1);

-//    char *pVal, dummy1[1024];

-//    short dummy, dummy2;

-//

-//    while (*in && out < bound)

-//    {

-//        switch (*in)

-//        {

-//        case '%':

-//            ++in;

-//            break;

-//

-//        default:

-//            *out++ = *in++;

-//            continue;

-//        }

-//

-//        /* handle % escape sequence */

-//        switch (*in++)

-//        {

-//        case '0':

-//            dummy = 0; dummy2 = 0;

-//            if (MP4GetMetadataTrack(file, &dummy, &dummy2))

-//            {

-//                out += wsprintf(out, "%d", (int)dummy);

-//                some_info = 1;

-//            }

-//            break;

-//

-//        case '1':

-//            pVal = NULL;

-//            if (MP4GetMetadataArtist(file, &pVal))

-//            {

-//                out += wsprintf(out, "%s", pVal);

-//                some_info = 1;

-//            }

-//            break;

-//

-//        case '2':

-//            pVal = NULL;

-//            if (MP4GetMetadataName(file, &pVal))

-//            {

-//                out += wsprintf(out, "%s", pVal);

-//                some_info = 1;

-//            }

-//            break;

-//

-//        case '3':

-//            pVal = NULL;

-//            if (MP4GetMetadataAlbum(file, &pVal))

-//            {

-//                out += wsprintf(out, "%s", pVal);

-//                some_info = 1;

-//            }

-//            break;

-//

-//        case '4':

-//            pVal = NULL;

-//            if (MP4GetMetadataYear(file, &pVal))

-//            {

-//                out += wsprintf(out, "%s", pVal);

-//                some_info = 1;

-//            }

-//            break;

-//

-//        case '5':

-//            pVal = NULL;

-//            if (MP4GetMetadataComment(file, &pVal))

-//            {

-//                out += wsprintf(out, "%s", pVal);

-//                some_info = 1;

-//            }

-//            break;

-//

-//        case '6':

-//            pVal = NULL;

-//            if (MP4GetMetadataGenre(file, &pVal))

-//            {

-//                out += wsprintf(out, "%s", pVal);

-//                some_info = 1;

-//            }

-//            break;

-//

-//        case '7':

-//            {

-//                const char *p=strrchr(filename,'\\');

-//                if (!p) p=filename; else p++;

-//                out += ConvertANSIToUTF8(p, out);

-//                some_info = 1;

-//                break;

-//            }

-//

-//        default:

-//            break;

-//        }

-//    }

-//

-//    *out = '\0';

-//

-//    if (!some_info)

-//    {

-//        char *p=filename+lstrlen(filename);

-//        while (*p != '\\' && p >= filename) p--;

-//        lstrcpy(title,++p);

-//    }

-//    else

-//    {

-//        int len = ConvertUTF8ToANSI(temp, dummy1);

-//        if (len > (MAX_PATH - 10 - 1)) len = (MAX_PATH - 10 - 1);

-//        memcpy(title, dummy1, len);

-//        title[len] = '\0';

-//    }

-//}

-

-BOOL CALLBACK config_dialog_proc(HWND hwndDlg, UINT message,

-                                 WPARAM wParam, LPARAM lParam)

-{

-    int i;

-

-    switch (message) {

-    case WM_INITDIALOG:

-        SendMessage(GetDlgItem(hwndDlg, IDC_PRIORITY), TBM_SETRANGE, TRUE, MAKELONG(1,5));

-        SendMessage(GetDlgItem(hwndDlg, IDC_PRIORITY), TBM_SETPOS, TRUE, m_priority);

-        SendMessage(GetDlgItem(hwndDlg, res_id_table[m_resolution]), BM_SETCHECK, BST_CHECKED, 0);

-        if (m_show_errors)

-            SendMessage(GetDlgItem(hwndDlg, IDC_ERROR), BM_SETCHECK, BST_CHECKED, 0);

-        if (m_use_for_aac)

-            SendMessage(GetDlgItem(hwndDlg, IDC_USEFORAAC), BM_SETCHECK, BST_CHECKED, 0);

-        if (m_downmix)

-            SendMessage(GetDlgItem(hwndDlg, IDC_DOWNMIX), BM_SETCHECK, BST_CHECKED, 0);

-        if (m_vbr_display)

-            SendMessage(GetDlgItem(hwndDlg, IDC_VBR), BM_SETCHECK, BST_CHECKED, 0);

-        SetDlgItemText(hwndDlg, IDC_TITLEFORMAT, titleformat);

-        return TRUE;

-

-    case WM_COMMAND:

-        switch (LOWORD(wParam)) {

-        case IDCANCEL:

-            EndDialog(hwndDlg, wParam);

-            return TRUE;

-        case IDOK:

-            m_show_errors = SendMessage(GetDlgItem(hwndDlg, IDC_ERROR), BM_GETCHECK, 0, 0);

-            m_use_for_aac = SendMessage(GetDlgItem(hwndDlg, IDC_USEFORAAC), BM_GETCHECK, 0, 0);

-            m_downmix = SendMessage(GetDlgItem(hwndDlg, IDC_DOWNMIX), BM_GETCHECK, 0, 0);

-            m_vbr_display = SendMessage(GetDlgItem(hwndDlg, IDC_VBR), BM_GETCHECK, 0, 0);

-            GetDlgItemText(hwndDlg, IDC_TITLEFORMAT, titleformat, MAX_PATH);

-

-            m_priority = SendMessage(GetDlgItem(hwndDlg, IDC_PRIORITY), TBM_GETPOS, 0, 0);

-            for (i = 0; i < 6; i++)

-            {

-                if (SendMessage(GetDlgItem(hwndDlg, res_id_table[i]), BM_GETCHECK, 0, 0))

-                {

-                    m_resolution = i;

-                    break;

-                }

-            }

-

-            /* save config */

-            config_write();

-

-            //if (!m_use_for_aac)

-            //{

-            //    module.FileExtensions = short_ext_list;

-            //} else {

-            //    module.FileExtensions = long_ext_list;

-            //}

-

-            EndDialog(hwndDlg, wParam);

-            return TRUE;

-        }

-    }

-    return FALSE;

-}

-

-void Configure(int flags)

-{

-    DialogBox(module.hDllInstance, MAKEINTRESOURCE(IDD_CONFIG),

-		module.hMainWindow, config_dialog_proc);

-}

-

-//-----------------------------------------------------------------------------

-

-void About(int flags)

-{

-	MessageBox(module.hMainWindow,

-        "AudioCoding.com MPEG-4 General Audio player " FAAD2_VERSION " compiled on " __DATE__ ".\n"

-        "Visit the website for more info.\n"

-		"Ported to QCD by Shao Hao.\n"

-        "Copyright 2002-2003 AudioCoding.com",

-        "About",

-        MB_OK);

-}

-

-//-----------------------------------------------------------------------------

-

-int fill_buffer(state *st)

-{

-    int bread;

-

-    if (st->m_aac_bytes_consumed > 0)

-    {

-        if (st->m_aac_bytes_into_buffer)

-        {

-            memmove((void*)st->m_aac_buffer, (void*)(st->m_aac_buffer + st->m_aac_bytes_consumed),

-                st->m_aac_bytes_into_buffer*sizeof(unsigned char));

-        }

-

-        if (!st->m_at_eof)

-        {

-            bread = fread((void*)(st->m_aac_buffer + st->m_aac_bytes_into_buffer),

-                1, st->m_aac_bytes_consumed, st->aacfile);

-

-            if (bread != st->m_aac_bytes_consumed)

-                st->m_at_eof = 1;

-

-            st->m_aac_bytes_into_buffer += bread;

-        }

-

-        st->m_aac_bytes_consumed = 0;

-

-        if (st->m_aac_bytes_into_buffer > 3)

-        {

-            if (memcmp(st->m_aac_buffer, "TAG", 3) == 0)

-                st->m_aac_bytes_into_buffer = 0;

-        }

-        if (st->m_aac_bytes_into_buffer > 11)

-        {

-            if (memcmp(st->m_aac_buffer, "LYRICSBEGIN", 11) == 0)

-                st->m_aac_bytes_into_buffer = 0;

-        }

-        if (st->m_aac_bytes_into_buffer > 8)

-        {

-            if (memcmp(st->m_aac_buffer, "APETAGEX", 8) == 0)

-                st->m_aac_bytes_into_buffer = 0;

-        }

-    }

-

-    return 1;

-}

-

-void advance_buffer(state *st, int bytes)

-{

-    st->m_file_offset += bytes;

-    st->m_aac_bytes_consumed = bytes;

-    st->m_aac_bytes_into_buffer -= bytes;

-}

-

-int adts_parse(state *st, __int64 *bitrate, double *length)

-{

-    static int sample_rates[] = {96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000};

-    int frames, frame_length;

-    int t_framelength = 0;

-    int samplerate;

-    double frames_per_sec, bytes_per_frame;

-

-    /* Read all frames to ensure correct time and bitrate */

-    for (frames = 0; /* */; frames++)

-    {

-        fill_buffer(st);

-

-        if (st->m_aac_bytes_into_buffer > 7)

-        {

-            /* check syncword */

-            if (!((st->m_aac_buffer[0] == 0xFF)&&((st->m_aac_buffer[1] & 0xF6) == 0xF0)))

-                break;

-

-            st->m_tail->offset = st->m_file_offset;

-            st->m_tail->next = (struct seek_list*)malloc(sizeof(struct seek_list));

-            st->m_tail = st->m_tail->next;

-            st->m_tail->next = NULL;

-

-            if (frames == 0)

-                samplerate = sample_rates[(st->m_aac_buffer[2]&0x3c)>>2];

-

-            frame_length = ((((unsigned int)st->m_aac_buffer[3] & 0x3)) << 11)

-                | (((unsigned int)st->m_aac_buffer[4]) << 3) | (st->m_aac_buffer[5] >> 5);

-

-            t_framelength += frame_length;

-

-            if (frame_length > st->m_aac_bytes_into_buffer)

-                break;

-

-            advance_buffer(st, frame_length);

-        } else {

-            break;

-        }

-    }

-

-    frames_per_sec = (double)samplerate/1024.0;

-    if (frames != 0)

-        bytes_per_frame = (double)t_framelength/(double)(frames*1000);

-    else

-        bytes_per_frame = 0;

-    *bitrate = (__int64)(8. * bytes_per_frame * frames_per_sec + 0.5);

-    if (frames_per_sec != 0)

-        *length = (double)frames/frames_per_sec;

-    else

-        *length = 1;

-

-    return 1;

-}

-

-int skip_id3v2_tag()

-{

-    unsigned char buf[10];

-    int bread, tagsize = 0;

-

-    bread = fread(buf, 1, 10, mp4state.aacfile);

-    if (bread != 10) return -1;

-

-    if (!memcmp(buf, "ID3", 3))

-    {

-        /* high bit is not used */

-        tagsize = (buf[6] << 21) | (buf[7] << 14) | (buf[8] << 7) | (buf[9] << 0);

-

-        tagsize += 10;

-        fseek(mp4state.aacfile, tagsize, SEEK_SET);

-    } else {

-        fseek(mp4state.aacfile, 0, SEEK_SET);

-    }

-

-    return tagsize;

-}

-

-int GetMediaSupported(const char* medianame, MediaInfo *mediaInfo) 

-{

-    int tagsize = 0, init;

-

-	if (!medianame || !*medianame)

-		return 0;

-

-    if (!stricmp(medianame + strlen(medianame) - 3,"MP4") || !stricmp(medianame + strlen(medianame) - 3,"M4A"))

-    {

-		if (mediaInfo)

-		{

-			mediaInfo->mediaType = DIGITAL_FILE_MEDIA;

-			mediaInfo->op_canSeek = 1;

-		}

-		return 1;

-	}

-	else if (m_use_for_aac && !stricmp(medianame + strlen(medianame) - 3,"AAC"))

-	{

-		if (mediaInfo)

-		{

-			mediaInfo->mediaType = DIGITAL_FILE_MEDIA;

-			mediaInfo->op_canSeek = 1;

-

-			memset(&mp4state, 0, sizeof(state));

-			lstrcpy(mp4state.filename, medianame);

-

-			if (!(mp4state.aacfile = fopen(mp4state.filename, "rb")))

-			{

-				// error

-				return 0;

-			}

-

-			tagsize = skip_id3v2_tag();

-			if (tagsize<0) return 0;

-

-			if (!(mp4state.m_aac_buffer = (unsigned char*)malloc(768*6)))

-			{

-				show_error(module.hMainWindow, "Memory allocation error.");

-				return 0;

-			}

-

-			for (init=0; init<2; init++)

-			{

-				memset(mp4state.m_aac_buffer, 0, 768*6);

-				fread(mp4state.m_aac_buffer, 1, 768*6, mp4state.aacfile);

-

-				if (init==0)

-					fseek(mp4state.aacfile, tagsize, SEEK_SET);

-			}

-

-			if (memcmp(mp4state.m_aac_buffer, "ADIF", 4) == 0)

-				mediaInfo->op_canSeek = (double)file_length(mp4state.aacfile) == -1 ? 0 : 1;

-

-			free(mp4state.m_aac_buffer);

-

-			fclose(mp4state.aacfile);

-		}

-		return 1;

-	}

-

-	return 0;

-}

-

-//-----------------------------------------------------------------------------

-

-int Play(const char* medianame, int playfrom, int playto, int flags)

-{

-    WAVEFORMATEX wf;

-    //int maxlatency;

-    int thread_id;

-    int avg_bitrate, br, sr;

-    unsigned char *buffer;

-    int buffer_size;

-    faacDecConfigurationPtr config;

-

-#ifdef DEBUG_OUTPUT

-    in_mp4_DebugOutput("play");

-#endif

-

-	if (stricmp(mp4state.filename, medianame) != 0)

-		Stop(mp4state.filename, STOPFLAG_PLAYDONE);

-

-	if (mp4state.paused)

-	{

-		// Update the player controls to reflect the new unpaused state

-		module.QCDCallbacks.toPlayer.OutputPause(0);

-

-		Pause(medianame, 0);

-

-		if (playfrom >= 0)

-			mp4state.seek_needed = playfrom;

-	}

-	else if (PlayThreadAlive) // is playing

-	{

-		mp4state.seek_needed = playfrom;

-		return 1;

-	}

-	else

-	{

-    memset(&mp4state, 0, sizeof(state));

-

-    lstrcpy(mp4state.filename, medianame);

-

-    if (!(mp4state.mp4file = MP4Read(mp4state.filename, 0)))

-    {

-        mp4state.filetype = 1;

-    } else {

-        MP4Close(mp4state.mp4file);

-        mp4state.filetype = 0;

-    }

-

-    if (mp4state.filetype)

-    {

-        int tagsize = 0, tmp = 0, init;

-        int bread = 0;

-        double length = 0.;

-        __int64 bitrate = 128;

-

-        //module.is_seekable = 1;

-

-        if (!(mp4state.aacfile = fopen(mp4state.filename, "rb")))

-        {

-            // error

-            return -1;

-        }

-

-        tagsize = skip_id3v2_tag();

-        if (tagsize<0) return 0;

-

-        if (!(mp4state.m_aac_buffer = (unsigned char*)malloc(768*6)))

-        {

-            show_error(module.hMainWindow, "Memory allocation error.");

-            return -1;

-        }

-

-        for (init=0; init<2; init++)

-        {

-            mp4state.hDecoder = faacDecOpen();

-            if (!mp4state.hDecoder)

-            {

-                show_error(module.hMainWindow, "Unable to open decoder library.");

-                return -1;

-            }

-

-            config = faacDecGetCurrentConfiguration(mp4state.hDecoder);

-            config->outputFormat = m_resolution + 1;

-            config->downMatrix = m_downmix;

-            faacDecSetConfiguration(mp4state.hDecoder, config);

-

-            memset(mp4state.m_aac_buffer, 0, 768*6);

-            bread = fread(mp4state.m_aac_buffer, 1, 768*6, mp4state.aacfile);

-            mp4state.m_aac_bytes_into_buffer = bread;

-            mp4state.m_aac_bytes_consumed = 0;

-            mp4state.m_file_offset = 0;

-            mp4state.m_at_eof = (bread != 768*6) ? 1 : 0;

-

-            if (init==0)

-            {

-                faacDecFrameInfo frameInfo;

-

-                fill_buffer(&mp4state);

-

-                if ((mp4state.m_aac_bytes_consumed = faacDecInit(mp4state.hDecoder,

-                    mp4state.m_aac_buffer, mp4state.m_aac_bytes_into_buffer,

-                    &mp4state.samplerate, &mp4state.channels)) < 0)

-                {

-                    show_error(module.hMainWindow, "Can't initialize decoder library.");

-                    return -1;

-                }

-                advance_buffer(&mp4state, mp4state.m_aac_bytes_consumed);

-

-                do {

-                    memset(&frameInfo, 0, sizeof(faacDecFrameInfo));

-                    fill_buffer(&mp4state);

-                    faacDecDecode(mp4state.hDecoder, &frameInfo, mp4state.m_aac_buffer, mp4state.m_aac_bytes_into_buffer);

-                } while (!frameInfo.samples && !frameInfo.error);

-

-                if (frameInfo.error)

-                {

-                    show_error(module.hMainWindow, faacDecGetErrorMessage(frameInfo.error));

-                    return -1;

-                }

-

-                mp4state.channels = frameInfo.channels;

-                mp4state.samplerate = frameInfo.samplerate;

-                mp4state.framesize = (frameInfo.channels != 0) ? frameInfo.samples/frameInfo.channels : 0;

-                /*

-                sbr = frameInfo.sbr;

-                profile = frameInfo.object_type;

-                header_type = frameInfo.header_type;

-                */

-

-                faacDecClose(mp4state.hDecoder);

-                fseek(mp4state.aacfile, tagsize, SEEK_SET);

-            }

-        }

-

-        mp4state.m_head = (struct seek_list*)malloc(sizeof(struct seek_list));

-        mp4state.m_tail = mp4state.m_head;

-        mp4state.m_tail->next = NULL;

-

-        mp4state.m_header_type = 0;

-        if ((mp4state.m_aac_buffer[0] == 0xFF) && ((mp4state.m_aac_buffer[1] & 0xF6) == 0xF0))

-        {

-            if (1) //(can_seek)

-            {

-                adts_parse(&mp4state, &bitrate, &length);

-                fseek(mp4state.aacfile, tagsize, SEEK_SET);

-

-                bread = fread(mp4state.m_aac_buffer, 1, 768*6, mp4state.aacfile);

-                if (bread != 768*6)

-                    mp4state.m_at_eof = 1;

-                else

-                    mp4state.m_at_eof = 0;

-                mp4state.m_aac_bytes_into_buffer = bread;

-                mp4state.m_aac_bytes_consumed = 0;

-

-                mp4state.m_header_type = 1;

-            }

-        } else if (memcmp(mp4state.m_aac_buffer, "ADIF", 4) == 0) {

-            int skip_size = (mp4state.m_aac_buffer[4] & 0x80) ? 9 : 0;

-            bitrate = ((unsigned int)(mp4state.m_aac_buffer[4 + skip_size] & 0x0F)<<19) |

-                ((unsigned int)mp4state.m_aac_buffer[5 + skip_size]<<11) |

-                ((unsigned int)mp4state.m_aac_buffer[6 + skip_size]<<3) |

-                ((unsigned int)mp4state.m_aac_buffer[7 + skip_size] & 0xE0);

-

-            length = (double)file_length(mp4state.aacfile);

-            if (length == -1)

-            {

-                //module.is_seekable = 0;

-                length = 0;

-            } else {

-                length = ((double)length*8.)/((double)bitrate) + 0.5;

-            }

-

-            mp4state.m_header_type = 2;

-        } else {

-            length = (double)file_length(mp4state.aacfile);

-            length = ((double)length*8.)/((double)bitrate*1000.) + 0.5;

-

-            //module.is_seekable = 1;

-        }

-

-        mp4state.m_length = (int)(length*1000.);

-

-        fill_buffer(&mp4state);

-        if ((mp4state.m_aac_bytes_consumed = faacDecInit(mp4state.hDecoder,

-            mp4state.m_aac_buffer, mp4state.m_aac_bytes_into_buffer,

-            &mp4state.samplerate, &mp4state.channels)) < 0)

-        {

-            show_error(module.hMainWindow, "Can't initialize decoder library.");

-            return -1;

-        }

-        advance_buffer(&mp4state, mp4state.m_aac_bytes_consumed);

-

-        if (mp4state.m_header_type == 2)

-            avg_bitrate = bitrate;

-        else

-            avg_bitrate = bitrate*1000;

-    } else {

-        mp4state.hDecoder = faacDecOpen();

-        if (!mp4state.hDecoder)

-        {

-            show_error(module.hMainWindow, "Unable to open decoder library.");

-            return -1;

-        }

-

-        config = faacDecGetCurrentConfiguration(mp4state.hDecoder);

-        config->outputFormat = m_resolution + 1;

-        config->downMatrix = m_downmix;

-        faacDecSetConfiguration(mp4state.hDecoder, config);

-

-        mp4state.mp4file = MP4Read(mp4state.filename, 0);

-        if (!mp4state.mp4file)

-        {

-            show_error(module.hMainWindow, "Unable to open file.");

-            faacDecClose(mp4state.hDecoder);

-            return -1;

-        }

-

-        if ((mp4state.mp4track = GetAACTrack(mp4state.mp4file)) < 0)

-        {

-            show_error(module.hMainWindow, "Unsupported Audio track type.");

-            faacDecClose(mp4state.hDecoder);

-            MP4Close(mp4state.mp4file);

-            return -1;

-        }

-

-        buffer = NULL;

-        buffer_size = 0;

-        MP4GetTrackESConfiguration(mp4state.mp4file, mp4state.mp4track,

-            &buffer, &buffer_size);

-        if (!buffer)

-        {

-            faacDecClose(mp4state.hDecoder);

-            MP4Close(mp4state.mp4file);

-            return -1;

-        }

-

-        if(faacDecInit2(mp4state.hDecoder, buffer, buffer_size,

-            &mp4state.samplerate, &mp4state.channels) < 0)

-        {

-            /* If some error initializing occured, skip the file */

-            faacDecClose(mp4state.hDecoder);

-            MP4Close(mp4state.mp4file);

-            if (buffer) free (buffer);

-            return -1;

-        }

-

-        /* for gapless decoding */

-        {

-            mp4AudioSpecificConfig mp4ASC;

-

-            mp4state.timescale = MP4GetTrackTimeScale(mp4state.mp4file, mp4state.mp4track);

-            mp4state.framesize = 1024;

-            mp4state.useAacLength = 0;

-

-            if (buffer)

-            {

-                if (AudioSpecificConfig(buffer, buffer_size, &mp4ASC) >= 0)

-                {

-                    if (mp4ASC.frameLengthFlag == 1) mp4state.framesize = 960;

-                    if (mp4ASC.sbr_present_flag == 1) mp4state.framesize *= 2;

-                }

-            }

-        }

-

-        free(buffer);

-

-        avg_bitrate = MP4GetTrackIntegerProperty(mp4state.mp4file, mp4state.mp4track,

-            "mdia.minf.stbl.stsd.mp4a.esds.decConfigDescr.avgBitrate");

-

-        mp4state.numSamples = MP4GetTrackNumberOfSamples(mp4state.mp4file, mp4state.mp4track);

-        mp4state.sampleId = 1;

-

-        //module.is_seekable = 1;

-    }

-

-    if (mp4state.channels == 0)

-    {

-        show_error(module.hMainWindow, "Number of channels not supported for playback.");

-        faacDecClose(mp4state.hDecoder);

-        if (mp4state.filetype)

-            fclose(mp4state.aacfile);

-        else

-            MP4Close(mp4state.mp4file);

-        return -1;

-    }

-

-    if (m_downmix && (mp4state.channels == 5 || mp4state.channels == 6))

-        mp4state.channels = 2;

-

-	wf.wFormatTag = WAVE_FORMAT_PCM;

-	wf.cbSize = 0;

-	wf.nChannels = mp4state.channels;

-	wf.wBitsPerSample = res_table[m_resolution];

-	wf.nSamplesPerSec = mp4state.samplerate;

-	wf.nBlockAlign = wf.nChannels * wf.wBitsPerSample / 8;

-	wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;

-	if (!module.QCDCallbacks.toPlayer.OutputOpen(mp4state.filename, &wf)) // error opening device

-    {

-        faacDecClose(mp4state.hDecoder);

-        if (mp4state.filetype)

-            fclose(mp4state.aacfile);

-        else

-            MP4Close(mp4state.mp4file);

-        return -1;

-    }

-

-    mp4state.paused        =  0;

-    mp4state.decode_pos_ms =  0;

-    mp4state.seek_needed   = -1;

-

-    //// initialize vis stuff

-    //module.SAVSAInit(maxlatency, mp4state.samplerate);

-    //module.VSASetInfo((int)mp4state.channels, mp4state.samplerate);

-

-    br = (int)floor(((float)avg_bitrate + 500.0)/1000.0 + 0.5);

-    sr = (int)floor((float)mp4state.samplerate/1000.0 + 0.5);

-	ai.struct_size = sizeof(AudioInfo);

-	ai.frequency = sr*1000;

-	ai.bitrate = br*1000;

-	ai.mode = (mp4state.channels == 2) ? 0 : 3;

-	ai.layer = 0;

-	ai.level = 0;

-	strcpy(ai.text, mp4state.filetype ? "AAC" : "MP4");

-	module.QCDCallbacks.Service(opSetAudioInfo, &ai, sizeof(AudioInfo), 0);

-

-    //module.outMod->SetVolume(-666); // set the output plug-ins default volume

-

-    killPlayThread = 0;

-

-    if (mp4state.filetype)

-    {

-        if ((play_thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)AACPlayThread,

-            (void *)&killPlayThread, 0, &thread_id)) == NULL)

-        {

-            show_error(module.hMainWindow, "Cannot create playback thread");

-            faacDecClose(mp4state.hDecoder);

-            fclose(mp4state.aacfile);

-            return -1;

-        }

-    } else {

-        if ((play_thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)MP4PlayThread,

-            (void *)&killPlayThread, 0, &thread_id)) == NULL)

-        {

-            show_error(module.hMainWindow, "Cannot create playback thread");

-            faacDecClose(mp4state.hDecoder);

-            MP4Close(mp4state.mp4file);

-            return -1;

-        }

-    }

-

-    SetThreadAffinityMask(play_thread_handle, 1);

-

-    SetThreadPriority(play_thread_handle, priority_table[m_priority]);

-	}

-

-    return 1;

-}

-

-//-----------------------------------------------------------------------------

-

-int Pause(const char* medianame, int flags)

-{

-#ifdef DEBUG_OUTPUT

-    in_mp4_DebugOutput("pause");

-#endif

-

-    mp4state.paused = flags;

-

-	if (module.QCDCallbacks.toPlayer.OutputPause(flags))

-		return 1;

-

-	mp4state.paused = !flags;

-	return 0;

-}

-

-//void unpause()

-//{

-//#ifdef DEBUG_OUTPUT

-//    in_mp4_DebugOutput("unpause");

-//#endif

-//

-//    mp4state.paused = 0;

-//    module.outMod->Pause(0);

-//}

-//

-//int ispaused()

-//{

-//#ifdef DEBUG_OUTPUT

-//    in_mp4_DebugOutput("ispaused");

-//#endif

-//

-//    return mp4state.paused;

-//}

-

-//-----------------------------------------------------------------------------

-

-void SetVolume(int levelleft, int levelright, int flags)

-{

-#ifdef DEBUG_OUTPUT

-    in_mp4_DebugOutput("setvolume");

-#endif

-

-	module.QCDCallbacks.toPlayer.OutputSetVol(levelleft, levelright, flags);

-}

-

-//void setpan(int pan)

-//{

-//#ifdef DEBUG_OUTPUT

-//    in_mp4_DebugOutput("setpan");

-//#endif

-//

-//    module.outMod->SetPan(pan);

-//}

-

-//-----------------------------------------------------------------------------

-

-int Stop(const char* medianame, int flags)

-{

-    struct seek_list *target = mp4state.m_head;

-

-#ifdef DEBUG_OUTPUT

-    in_mp4_DebugOutput("stop");

-#endif

-

-	if (medianame && *medianame && stricmp(mp4state.filename, medianame) == 0)

-	{

-	module.QCDCallbacks.toPlayer.OutputStop(flags);

-    killPlayThread = 1;

-

-    if (play_thread_handle != INVALID_HANDLE_VALUE)

-    {

-        if (WaitForSingleObject(play_thread_handle, INFINITE) == WAIT_TIMEOUT)

-            TerminateThread(play_thread_handle,0);

-        CloseHandle(play_thread_handle);

-        play_thread_handle = INVALID_HANDLE_VALUE;

-    }

-

-

-    if (mp4state.m_aac_buffer)

-        free(mp4state.m_aac_buffer);

-

-    while (target)

-    {

-        struct seek_list *tmp = target;

-        target = target->next;

-        if (tmp) free(tmp);

-    }

-    faacDecClose(mp4state.hDecoder);

-    if (mp4state.filetype)

-        fclose(mp4state.aacfile);

-    else

-        MP4Close(mp4state.mp4file);

-

-    //module.outMod->Close();

-    //module.SAVSADeInit();

-	mp4state.filename[0] = '\0';

-	mp4state.paused = 0;

-	}

-

-	return 1;

-}

-

-int getsonglength(const char *fn)

-{

-    long msDuration = 0;

-

-    if(!stricmp(fn + strlen(fn) - 3,"MP4") || !stricmp(fn + strlen(fn) - 3,"M4A"))

-    {

-        int track;

-        MP4Duration length;

-        MP4FileHandle file;

-

-        file = MP4Read(fn, 0);

-        if (!file)

-            return 0;

-

-        if ((track = GetAACTrack(file)) < 0)

-        {

-            MP4Close(file);

-            return -1;

-        }

-

-        length = MP4GetTrackDuration(file, track);

-

-        msDuration = MP4ConvertFromTrackDuration(file, track,

-            length, MP4_MSECS_TIME_SCALE);

-

-        MP4Close(file);

-

-        return msDuration;

-    } else {

-        int tagsize = 0;

-        int bread = 0;

-        double length = 0.;

-        __int64 bitrate = 128;

-        struct seek_list *target;

-        state len_state;

-

-        memset(&len_state, 0, sizeof(state));

-

-        if (!(len_state.aacfile = fopen(fn, "rb")))

-        {

-            // error

-            return 0;

-        }

-

-        len_state.m_at_eof = 0;

-

-        if (!(len_state.m_aac_buffer = (unsigned char*)malloc(768*6)))

-        {

-            //console::error("Memory allocation error.", "foo_mp4");

-            return 0;

-        }

-        memset(len_state.m_aac_buffer, 0, 768*6);

-

-        bread = fread(len_state.m_aac_buffer, 1, 768*6, len_state.aacfile);

-        len_state.m_aac_bytes_into_buffer = bread;

-        len_state.m_aac_bytes_consumed = 0;

-        len_state.m_file_offset = 0;

-

-        if (bread != 768*6)

-            len_state.m_at_eof = 1;

-

-        if (!memcmp(len_state.m_aac_buffer, "ID3", 3))

-        {

-            /* high bit is not used */

-            tagsize = (len_state.m_aac_buffer[6] << 21) | (len_state.m_aac_buffer[7] << 14) |

-                (len_state.m_aac_buffer[8] <<  7) | (len_state.m_aac_buffer[9] <<  0);

-

-            tagsize += 10;

-            advance_buffer(&len_state, tagsize);

-        }

-

-        len_state.m_head = (struct seek_list*)malloc(sizeof(struct seek_list));

-        len_state.m_tail = len_state.m_head;

-        len_state.m_tail->next = NULL;

-

-        len_state.m_header_type = 0;

-        if ((len_state.m_aac_buffer[0] == 0xFF) && ((len_state.m_aac_buffer[1] & 0xF6) == 0xF0))

-        {

-            if (1) //(m_reader->can_seek())

-            {

-                adts_parse(&len_state, &bitrate, &length);

-                fseek(len_state.aacfile, tagsize, SEEK_SET);

-

-                bread = fread(len_state.m_aac_buffer, 1, 768*6, len_state.aacfile);

-                if (bread != 768*6)

-                    len_state.m_at_eof = 1;

-                else

-                    len_state.m_at_eof = 0;

-                len_state.m_aac_bytes_into_buffer = bread;

-                len_state.m_aac_bytes_consumed = 0;

-

-                len_state.m_header_type = 1;

-            }

-        } else if (memcmp(len_state.m_aac_buffer, "ADIF", 4) == 0) {

-            int skip_size = (len_state.m_aac_buffer[4] & 0x80) ? 9 : 0;

-            bitrate = ((unsigned int)(len_state.m_aac_buffer[4 + skip_size] & 0x0F)<<19) |

-                ((unsigned int)len_state.m_aac_buffer[5 + skip_size]<<11) |

-                ((unsigned int)len_state.m_aac_buffer[6 + skip_size]<<3) |

-                ((unsigned int)len_state.m_aac_buffer[7 + skip_size] & 0xE0);

-

-            length = (double)file_length(len_state.aacfile);

-            if (length == -1)

-                length = 0;

-            else

-                length = ((double)length*8.)/((double)bitrate) + 0.5;

-

-            len_state.m_header_type = 2;

-        } else {

-            length = (double)file_length(len_state.aacfile);

-            length = ((double)length*8.)/((double)bitrate*1000.) + 0.5;

-

-            len_state.m_header_type = 0;

-        }

-

-        if (len_state.m_aac_buffer)

-            free(len_state.m_aac_buffer);

-

-        target = len_state.m_head;

-        while (target)

-        {

-            struct seek_list *tmp = target;

-            target = target->next;

-            if (tmp) free(tmp);

-        }

-

-        fclose(len_state.aacfile);

-

-        return (int)(length*1000.);

-    }

-}

-

-//int getlength()

-//{

-//    if (!mp4state.filetype)

-//    {

-//        int track;

-//        long msDuration;

-//        MP4Duration length;

-//

-//        if ((track = GetAACTrack(mp4state.mp4file)) < 0)

-//        {

-//            return -1;

-//        }

-//

-//        length = MP4GetTrackDuration(mp4state.mp4file, track);

-//

-//        msDuration = MP4ConvertFromTrackDuration(mp4state.mp4file, track,

-//            length, MP4_MSECS_TIME_SCALE);

-//

-//        return msDuration;

-//    } else {

-//        return mp4state.m_length;

-//    }

-//    return 0;

-//}

-

-//-----------------------------------------------------------------------------

-

-int GetCurrentPosition(const char* medianame, long *track, long *offset)

-{

-	return module.QCDCallbacks.toPlayer.OutputGetCurrentPosition((UINT*)offset, 0);

-}

-

-//void setoutputtime(int time_in_ms)

-//{

-//#ifdef DEBUG_OUTPUT

-//    in_mp4_DebugOutput("setoutputtime");

-//#endif

-//

-//    mp4state.seek_needed = time_in_ms;

-//}

-

-//-----------------------------------------------------------------------------

-

-int GetTrackExtents(const char* medianame, TrackExtents *ext, int flags)

-{

-	int len;

-	FILE *fh;

-

-	len = getsonglength((char *)medianame);

-	fh = fopen(medianame, "rb");

-	if (len <= 0 || !fh)

-		return 0;

-

-	ext->track = 1;

-	ext->start = 0;

-	ext->end = len;

-	ext->bytesize = file_length(fh);

-	fclose(fh);

-	ext->unitpersec = 1000;

-

-	return 1;

-}

-

-//void eq_set(int on, char data[10], int preamp)

-//{

-//}

-

-static void remap_channels(unsigned char *data, unsigned int samples, unsigned int bps)

-{

-    unsigned int i;

-

-    switch (bps)

-    {

-    case 8:

-        {

-            unsigned char r1, r2, r3, r4, r5, r6;

-            for (i = 0; i < samples; i += 6)

-            {

-                r1 = data[i];

-                r2 = data[i+1];

-                r3 = data[i+2];

-                r4 = data[i+3];

-                r5 = data[i+4];

-                r6 = data[i+5];

-                data[i] = r2;

-                data[i+1] = r3;

-                data[i+2] = r1;

-                data[i+3] = r6;

-                data[i+4] = r4;

-                data[i+5] = r5;

-            }

-        }

-        break;

-

-    case 16:

-    default:

-        {

-            unsigned short r1, r2, r3, r4, r5, r6;

-            unsigned short *sample_buffer = (unsigned short *)data;

-            for (i = 0; i < samples; i += 6)

-            {

-                r1 = sample_buffer[i];

-                r2 = sample_buffer[i+1];

-                r3 = sample_buffer[i+2];

-                r4 = sample_buffer[i+3];

-                r5 = sample_buffer[i+4];

-                r6 = sample_buffer[i+5];

-                sample_buffer[i] = r2;

-                sample_buffer[i+1] = r3;

-                sample_buffer[i+2] = r1;

-                sample_buffer[i+3] = r6;

-                sample_buffer[i+4] = r4;

-                sample_buffer[i+5] = r5;

-            }

-        }

-        break;

-

-    case 24:

-    case 32:

-        {

-            unsigned int r1, r2, r3, r4, r5, r6;

-            unsigned int *sample_buffer = (unsigned int *)data;

-            for (i = 0; i < samples; i += 6)

-            {

-                r1 = sample_buffer[i];

-                r2 = sample_buffer[i+1];

-                r3 = sample_buffer[i+2];

-                r4 = sample_buffer[i+3];

-                r5 = sample_buffer[i+4];

-                r6 = sample_buffer[i+5];

-                sample_buffer[i] = r2;

-                sample_buffer[i+1] = r3;

-                sample_buffer[i+2] = r1;

-                sample_buffer[i+3] = r6;

-                sample_buffer[i+4] = r4;

-                sample_buffer[i+5] = r5;

-            }

-        }

-        break;

-    }

-}

-

-DWORD WINAPI MP4PlayThread(void *b)

-{

-    int done = 0, updatepos = 0;

-    int l;

-    int seq_frames = 0;

-    int seq_bytes = 0;

-

-    void *sample_buffer;

-    unsigned char *buffer;

-    int buffer_size;

-    faacDecFrameInfo frameInfo;

-

-    WriteDataStruct wd;

-

-#ifdef DEBUG_OUTPUT

-    in_mp4_DebugOutput("MP4PlayThread");

-#endif

-

-    PlayThreadAlive = 1;

-    mp4state.last_frame = 0;

-    mp4state.initial = 1;

-

-    while (!*((int *)b))

-    {

-        /* seeking */

-        if (mp4state.seek_needed != -1)

-        {

-            MP4Duration duration;

-

-			module.QCDCallbacks.toPlayer.OutputFlush((unsigned int)mp4state.decode_pos_ms);

-            duration = MP4ConvertToTrackDuration(mp4state.mp4file,

-                mp4state.mp4track, mp4state.seek_needed, MP4_MSECS_TIME_SCALE);

-            mp4state.sampleId = MP4GetSampleIdFromTime(mp4state.mp4file,

-                mp4state.mp4track, duration, 0);

-

-            mp4state.decode_pos_ms = mp4state.seek_needed;

-            mp4state.seek_needed = -1;

-			updatepos = 1;

-        }

-

-        if (done)

-        {

-			if (module.QCDCallbacks.toPlayer.OutputDrain(0) && !(mp4state.seek_needed >= 0))

-			{

-				module.QCDCallbacks.toPlayer.OutputStop(STOPFLAG_PLAYDONE);

-				module.QCDCallbacks.toPlayer.PlayDone(mp4state.filename);

-                PlayThreadAlive = 0;

-			}

-			else if (mp4state.seek_needed >= 0)

-			{

-				done = 0;

-				continue;

-			}

-			break;

-        } else/* if (module.outMod->CanWrite() >= (2048*mp4state.channels*sizeof(short)))*/ {

-

-            if (mp4state.last_frame)

-            {

-                done = 1;

-            } else {

-                int rc;

-

-                /* for gapless decoding */

-                char *buf;

-                MP4Duration dur;

-                unsigned int sample_count;

-                unsigned int delay = 0;

-

-                /* get acces unit from MP4 file */

-                buffer = NULL;

-                buffer_size = 0;

-

-                rc = MP4ReadSample(mp4state.mp4file, mp4state.mp4track,

-                    mp4state.sampleId++, &buffer, &buffer_size,

-                    NULL, &dur, NULL, NULL);

-                if (mp4state.sampleId-1 == 1) dur = 0;

-                if (rc == 0 || buffer == NULL)

-                {

-                    mp4state.last_frame = 1;

-                    sample_buffer = NULL;

-                    frameInfo.samples = 0;

-                } else {

-                    sample_buffer = faacDecDecode(mp4state.hDecoder, &frameInfo,

-                        buffer, buffer_size);

-                }

-                if (frameInfo.error > 0)

-                {

-                    show_error(module.hMainWindow, faacDecGetErrorMessage(frameInfo.error));

-                    mp4state.last_frame = 1;

-                }

-                if (mp4state.sampleId > mp4state.numSamples)

-                    mp4state.last_frame = 1;

-

-                if (buffer) free(buffer);

-

-                if (mp4state.useAacLength || (mp4state.timescale != mp4state.samplerate)) {

-                    sample_count = frameInfo.samples;

-                } else {

-                    sample_count = (unsigned int)(dur * frameInfo.channels);

-

-                    if (!mp4state.useAacLength && !mp4state.initial && (mp4state.sampleId < mp4state.numSamples/2) && (dur*frameInfo.channels != frameInfo.samples))

-                    {

-                        //fprintf(stderr, "MP4 seems to have incorrect frame duration, using values from AAC data.\n");

-                        mp4state.useAacLength = 1;

-                        sample_count = frameInfo.samples;

-                    }

-                }

-

-                if (mp4state.initial && (sample_count < mp4state.framesize*mp4state.channels) && (frameInfo.samples > sample_count))

-                {

-                    delay = frameInfo.samples - sample_count;

-                }

-

-                if (!killPlayThread && (sample_count > 0))

-                {

-                    buf = (char *)sample_buffer;

-                    mp4state.initial = 0;

-

-                    switch (res_table[m_resolution])

-                    {

-                    case 8:

-                        buf += delay;

-                        break;

-                    case 16:

-                    default:

-                        buf += delay * 2;

-                        break;

-                    case 24:

-                    case 32:

-                        buf += delay * 4;

-                        break;

-                    case 64:

-                        buf += delay * 8;

-                    }

-

-                    if (frameInfo.channels == 6 && frameInfo.num_lfe_channels)

-                        remap_channels(buf, sample_count, res_table[m_resolution]);

-

-                    if (res_table[m_resolution] == 24)

-                    {

-                        /* convert libfaad output (3 bytes packed in 4) */

-                        char *temp_buffer = convert3in4to3in3(buf, sample_count);

-                        memcpy((void*)buf, (void*)temp_buffer, sample_count*3);

-                        free(temp_buffer);

-                    }

-

-                    //module.SAAddPCMData(buf, (int)mp4state.channels, res_table[m_resolution],

-                    //    mp4state.decode_pos_ms);

-                    //module.VSAAddPCMData(buf, (int)mp4state.channels, res_table[m_resolution],

-                    //    mp4state.decode_pos_ms);

-                    mp4state.decode_pos_ms += (double)sample_count * 1000.0 /

-                        ((double)frameInfo.samplerate * (double)frameInfo.channels);

-

-                    l = sample_count * res_table[m_resolution] / 8;

-

-					if (updatepos)

-					{

-						module.QCDCallbacks.toPlayer.PositionUpdate((unsigned int)mp4state.decode_pos_ms);

-						updatepos = 0;

-					}

-

-					wd.bytelen = l;

-					wd.data = (short*)buf;

-					wd.markerend = 0;

-					wd.markerstart = (UINT)mp4state.decode_pos_ms;

-					wd.bps = res_table[m_resolution];

-					wd.nch = frameInfo.channels;

-					wd.numsamples = sample_count/frameInfo.channels;

-					wd.srate = frameInfo.samplerate;

-

-					if (!module.QCDCallbacks.toPlayer.OutputWrite(&wd))

-						done = 1;

-

-                    //if (module.dsp_isactive())

-                    //{

-                    //    void *dsp_buffer = malloc(l*2);

-                    //    memcpy(dsp_buffer, buf, l);

-

-                    //    l = module.dsp_dosamples((short*)dsp_buffer,

-                    //        sample_count/frameInfo.channels,

-                    //        res_table[m_resolution],

-                    //        frameInfo.channels,

-                    //        frameInfo.samplerate) *

-                    //        (frameInfo.channels*(res_table[m_resolution]/8));

-

-                    //    module.outMod->Write(dsp_buffer, l);

-                    //    if (dsp_buffer) free(dsp_buffer);

-                    //} else {

-                    //    module.outMod->Write(buf, l);

-                    //}

-

-                    /* VBR bitrate display */

-                    if (m_vbr_display)

-                    {

-                        seq_frames++;

-                        seq_bytes += frameInfo.bytesconsumed;

-                        if (seq_frames == (int)(floor((float)frameInfo.samplerate/(float)(sample_count/frameInfo.channels) + 0.5)))

-                        {

-							ai.bitrate = (int)floor(((float)seq_bytes*8.)/1000. + 0.5) * 1000;

-							ai.frequency = (int)floor(frameInfo.samplerate/1000. + 0.5) * 1000;

-							ai.mode = (mp4state.channels == 2) ? 0 : 3;

-							module.QCDCallbacks.Service(opSetAudioInfo, &ai, sizeof(AudioInfo), 0);

-

-                            seq_frames = 0;

-                            seq_bytes = 0;

-                        }

-                    }

-                }

-            }

-        }

-		

-		Sleep(10);

-

-		// catch pause

-		while (mp4state.paused && !killPlayThread)

-			Sleep(50);

-    }

-

-    PlayThreadAlive = 0;

-

-    return 0;

-}

-

-void *decode_aac_frame(state *st, faacDecFrameInfo *frameInfo)

-{

-    void *sample_buffer = NULL;

-

-    do

-    {

-        fill_buffer(st);

-

-        if (st->m_aac_bytes_into_buffer != 0)

-        {

-            sample_buffer = faacDecDecode(st->hDecoder, frameInfo,

-                st->m_aac_buffer, st->m_aac_bytes_into_buffer);

-

-            if (st->m_header_type != 1)

-            {

-                if (st->last_offset < st->m_file_offset)

-                {

-                    st->m_tail->offset = st->m_file_offset;

-                    st->m_tail->next = (struct seek_list*)malloc(sizeof(struct seek_list));

-                    st->m_tail = st->m_tail->next;

-                    st->m_tail->next = NULL;

-                    st->last_offset = st->m_file_offset;

-                }

-            }

-

-            advance_buffer(st, frameInfo->bytesconsumed);

-        } else {

-            break;

-        }

-

-    } while (!frameInfo->samples && !frameInfo->error);

-

-    return sample_buffer;

-}

-

-int aac_seek(state *st, double seconds)

-{

-    int i, frames;

-    int bread;

-    struct seek_list *target = st->m_head;

-

-    if (1 /*can_seek*/ && ((st->m_header_type == 1) || (seconds < st->cur_pos_sec)))

-    {

-        frames = (int)(seconds*((double)st->samplerate/(double)st->framesize) + 0.5);

-

-        for (i = 0; i < frames; i++)

-        {

-            if (target->next)

-                target = target->next;

-            else

-                return 0;

-        }

-        if (target->offset == 0 && frames > 0)

-            return 0;

-        fseek(st->aacfile, target->offset, SEEK_SET);

-        st->m_file_offset = target->offset;

-

-        bread = fread(st->m_aac_buffer, 1, 768*6, st->aacfile);

-        if (bread != 768*6)

-            st->m_at_eof = 1;

-        else

-            st->m_at_eof = 0;

-        st->m_aac_bytes_into_buffer = bread;

-        st->m_aac_bytes_consumed = 0;

-        st->m_file_offset += bread;

-

-        faacDecPostSeekReset(st->hDecoder, -1);

-

-        return 1;

-    } else {

-        if (seconds > st->cur_pos_sec)

-        {

-            faacDecFrameInfo frameInfo;

-

-            frames = (int)((seconds - st->cur_pos_sec)*((double)st->samplerate/(double)st->framesize));

-

-            if (frames > 0)

-            {

-                for (i = 0; i < frames; i++)

-                {

-                    memset(&frameInfo, 0, sizeof(faacDecFrameInfo));

-                    decode_aac_frame(st, &frameInfo);

-

-                    if (frameInfo.error || (st->m_aac_bytes_into_buffer == 0))

-                    {

-                        if (frameInfo.error)

-                        {

-                            if (faacDecGetErrorMessage(frameInfo.error) != NULL)

-                                show_error(module.hMainWindow, faacDecGetErrorMessage(frameInfo.error));

-                        }

-                        return 0;

-                    }

-                }

-            }

-

-            faacDecPostSeekReset(st->hDecoder, -1);

-        }

-        return 1;

-    }

-}

-

-DWORD WINAPI AACPlayThread(void *b)

-{

-    int done = 0, updatepos = 0;

-    int l;

-    int seq_frames = 0;

-    int seq_bytes = 0;

-

-	WriteDataStruct wd;

-

-#ifdef DEBUG_OUTPUT

-    in_mp4_DebugOutput("AACPlayThread");

-#endif

-

-    PlayThreadAlive = 1;

-    mp4state.last_frame = 0;

-

-    while (!*((int *)b))

-    {

-        /* seeking */

-        if (mp4state.seek_needed != -1)

-        {

-            double ms;

-

-            ms = mp4state.seek_needed/1000;

-            if (aac_seek(&mp4state, ms)!=0)

-            {

-                module.QCDCallbacks.toPlayer.OutputFlush((unsigned int)mp4state.decode_pos_ms);

-                mp4state.cur_pos_sec = ms;

-                mp4state.decode_pos_ms = mp4state.seek_needed;

-            }

-            mp4state.seek_needed = -1;

-			updatepos = 1;

-        }

-

-        if (done)

-        {

-			if (module.QCDCallbacks.toPlayer.OutputDrain(0) && !(mp4state.seek_needed >= 0))

-			{

-				module.QCDCallbacks.toPlayer.OutputStop(STOPFLAG_PLAYDONE);

-				module.QCDCallbacks.toPlayer.PlayDone(mp4state.filename);

-                PlayThreadAlive = 0;

-			}

-			else if (mp4state.seek_needed >= 0)

-			{

-				done = 0;

-				continue;

-			}

-			break;

-        } else/* if (module.outMod->CanWrite() >= (2048*mp4state.channels*sizeof(short)))*/ {

-            faacDecFrameInfo frameInfo;

-            void *sample_buffer;

-

-            memset(&frameInfo, 0, sizeof(faacDecFrameInfo));

-

-            sample_buffer = decode_aac_frame(&mp4state, &frameInfo);

-

-            if (frameInfo.error || (mp4state.m_aac_bytes_into_buffer == 0))

-            {

-                if (frameInfo.error)

-                {

-                    if (faacDecGetErrorMessage(frameInfo.error) != NULL)

-                        show_error(module.hMainWindow, faacDecGetErrorMessage(frameInfo.error));

-                }

-                done = 1;

-            }

-

-            if (!killPlayThread && (frameInfo.samples > 0))

-            {

-                if (frameInfo.channels == 6 && frameInfo.num_lfe_channels)

-                    remap_channels(sample_buffer, frameInfo.samples, res_table[m_resolution]);

-

-                if (res_table[m_resolution] == 24)

-                {

-                    /* convert libfaad output (3 bytes packed in 4 bytes) */

-                    char *temp_buffer = convert3in4to3in3(sample_buffer, frameInfo.samples);

-                    memcpy((void*)sample_buffer, (void*)temp_buffer, frameInfo.samples*3);

-                    free(temp_buffer);

-                }

-

-                //module.SAAddPCMData(sample_buffer, (int)mp4state.channels, res_table[m_resolution],

-                //    mp4state.decode_pos_ms);

-                //module.VSAAddPCMData(sample_buffer, (int)mp4state.channels, res_table[m_resolution],

-                //    mp4state.decode_pos_ms);

-                mp4state.decode_pos_ms += (double)frameInfo.samples * 1000.0 /

-                    ((double)frameInfo.samplerate* (double)frameInfo.channels);

-

-                l = frameInfo.samples * res_table[m_resolution] / 8;

-

-				if (updatepos)

-				{

-					module.QCDCallbacks.toPlayer.PositionUpdate((unsigned int)mp4state.decode_pos_ms);

-					updatepos = 0;

-				}

-

-				wd.bytelen = l;

-				wd.data = (short*)sample_buffer;

-				wd.markerend = 0;

-				wd.markerstart = (UINT)mp4state.decode_pos_ms;

-				wd.bps = res_table[m_resolution];

-				wd.nch = frameInfo.channels;

-				wd.numsamples = frameInfo.samples/frameInfo.channels;

-				wd.srate = frameInfo.samplerate;

-

-				if (!module.QCDCallbacks.toPlayer.OutputWrite(&wd))

-					done = 1;

-

-                //if (module.dsp_isactive())

-                //{

-                //    void *dsp_buffer = malloc(l*2);

-                //    memcpy(dsp_buffer, sample_buffer, l);

-

-                //    l = module.dsp_dosamples((short*)dsp_buffer,

-                //        frameInfo.samples/frameInfo.channels,

-                //        res_table[m_resolution],

-                //        frameInfo.channels,

-                //        frameInfo.samplerate) *

-                //        (frameInfo.channels*(res_table[m_resolution]/8));

-

-                //    module.outMod->Write(dsp_buffer, l);

-                //    if (dsp_buffer) free(dsp_buffer);

-                //} else {

-                //    module.outMod->Write(sample_buffer, l);

-                //}

-

-                /* VBR bitrate display */

-                if (m_vbr_display)

-                {

-                    seq_frames++;

-                    seq_bytes += frameInfo.bytesconsumed;

-                    if (seq_frames == (int)(floor((float)frameInfo.samplerate/(float)(frameInfo.samples/frameInfo.channels) + 0.5)))

-                    {

-						ai.bitrate = (int)floor(((float)seq_bytes*8.)/1000. + 0.5) * 1000;

-						ai.frequency = (int)floor(frameInfo.samplerate/1000. + 0.5) * 1000;

-						ai.mode = (mp4state.channels == 2) ? 0 : 3;

-						module.QCDCallbacks.Service(opSetAudioInfo, &ai, sizeof(AudioInfo), 0);

-

-                        seq_frames = 0;

-                        seq_bytes = 0;

-                    }

-                }

-            }

-

-            if (frameInfo.channels > 0 && mp4state.samplerate > 0)

-                mp4state.cur_pos_sec += ((double)(frameInfo.samples/frameInfo.channels))/(double)mp4state.samplerate;

-        }

-		

-		Sleep(10);

-

-		// catch pause

-		while (mp4state.paused && !killPlayThread)

-			Sleep(50);

-    }

-

-    PlayThreadAlive = 0;

-

-    return 0;

-}

-

-//-----------------------------------------------------------------------------

-

-int WINAPI DllMain(HINSTANCE hInst, DWORD fdwReason, LPVOID pRes)

-{

-	if (fdwReason == DLL_PROCESS_ATTACH)

-	{

-		module.hDllInstance = hInst;

-	}

-	return 1;

-}

-

-//-----------------------------------------------------------------------------

-

-PLUGIN_API QCDModInitIn* INPUTDLL_ENTRY_POINT(QCDModInitIn *ModInit, QCDModInfo *ModInfo)

-{

-	module.QCDCallbacks.size						= sizeof(QCDModInitIn);

-	module.QCDCallbacks.version						= PLUGIN_API_VERSION;

-	module.QCDCallbacks.toModule.Initialize			= Initialize;

-	module.QCDCallbacks.toModule.ShutDown			= ShutDown;

-	module.QCDCallbacks.toModule.GetTrackExtents	= GetTrackExtents;

-	module.QCDCallbacks.toModule.GetMediaSupported	= GetMediaSupported;

-	module.QCDCallbacks.toModule.Play				= Play;

-	module.QCDCallbacks.toModule.Pause				= Pause;

-	module.QCDCallbacks.toModule.Stop				= Stop;

-	module.QCDCallbacks.toModule.About				= About;

-	module.QCDCallbacks.toModule.Configure			= Configure;	

-	module.QCDCallbacks.toModule.SetEQ				= NULL;

-	module.QCDCallbacks.toModule.SetVolume			= SetVolume;

-

-	return &module.QCDCallbacks;

-}

-

-///* new Media Library interface */

-//

-//int mp4_get_metadata(MP4FileHandle file, const char *item, char *dest, int dlen)

-//{

-//    char *pVal = NULL, dummy1[4096];

-//    short dummy = 0, dummy2 = 0;

-//

-//    if (dlen < 1) return 0;

-//

-//    if (!stricmp(item, "track") || !stricmp(item, "tracknumber"))

-//    {

-//        if (MP4GetMetadataTrack(file, &dummy, &dummy2))

-//        {

-//            wsprintf(dummy1, "%d", (int)dummy);

-//            strncpy(dest, dummy1, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "disc") || !stricmp(item, "disknumber"))

-//    {

-//        if (MP4GetMetadataDisk(file, &dummy, &dummy2))

-//        {

-//            wsprintf(dummy1, "%d", (int)dummy);

-//            strncpy(dest, dummy1, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "compilation"))

-//    {

-//        u_int8_t cpil = 0;

-//        if (MP4GetMetadataCompilation(file, &cpil))

-//        {

-//            wsprintf(dummy1, "%d", (int)cpil);

-//            strncpy(dest, dummy1, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "tempo"))

-//    {

-//        u_int16_t tempo = 0;

-//        if (MP4GetMetadataTempo(file, &tempo))

-//        {

-//            wsprintf(dummy1, "%d", (int)tempo);

-//            strncpy(dest, dummy1, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "artist"))

-//    {

-//        if (MP4GetMetadataArtist(file, &pVal))

-//        {

-//            strncpy(dest, pVal, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "writer"))

-//    {

-//        if (MP4GetMetadataWriter(file, &pVal))

-//        {

-//            strncpy(dest, pVal, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "title"))

-//    {

-//        if (MP4GetMetadataName(file, &pVal))

-//        {

-//            strncpy(dest, pVal, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "album"))

-//    {

-//        if (MP4GetMetadataAlbum(file, &pVal))

-//        {

-//            strncpy(dest, pVal, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "date") || !stricmp(item, "year"))

-//    {

-//        if (MP4GetMetadataYear(file, &pVal))

-//        {

-//            strncpy(dest, pVal, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "comment"))

-//    {

-//        if (MP4GetMetadataComment(file, &pVal))

-//        {

-//            strncpy(dest, pVal, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "genre"))

-//    {

-//        if (MP4GetMetadataGenre(file, &pVal))

-//        {

-//            strncpy(dest, pVal, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else if (!stricmp(item, "tool"))

-//    {

-//        if (MP4GetMetadataTool(file, &pVal))

-//        {

-//            strncpy(dest, pVal, dlen-1);

-//            dest[dlen-1] = '\0';

-//            return 1;

-//        }

-//    }

-//    else

-//    {

-//        u_int32_t valueSize = 0;

-//        u_int8_t *pValue = NULL;

-//

-//        if (MP4GetMetadataFreeForm(file, (char *)item, &pValue, &valueSize))

-//        {

-//            unsigned int len = (valueSize < (unsigned int)(dlen-1)) ? valueSize : (unsigned int)(dlen-1);

-//            memcpy(dest, pValue, len);

-//            dest[len] = '\0';

-//            return 1;

-//        }

-//    }

-//

-//    return 0;

-//}

-//

-//__declspec(dllexport) int winampGetExtendedFileInfo(const char *fn, const char *data, char *dest, int destlen)

-//{

-//    if (!fn || (fn && !*fn) || !destlen) return 0;

-//

-//    dest[0] = '\0';

-//

-//    if (!stricmp(data, "length"))

-//    {

-//        char temp[32];

-//        int len = getsonglength(fn);

-//        itoa(len, temp, 10);

-//        strncpy(dest, temp, destlen-1);

-//        dest[destlen-1] = '\0';

-//    }

-//    else

-//    {

-//        char temp[2048], temp2[2048];

-//        MP4FileHandle file = MP4Read(fn, 0);

-//        if (file == MP4_INVALID_FILE_HANDLE) return 0;

-//

-//        if (mp4_get_metadata(file, data, temp, sizeof(temp)))

-//        {

-//            int len = ConvertUTF8ToANSI(temp, temp2);

-//            if (len > destlen-1) len = destlen-1;

-//            memcpy(dest, temp2, len);

-//            dest[len] = '\0';

-//        }

-//

-//        MP4Close(file);

-//    }

-//

-//    return 1;

-//}

-//

-//static struct medialib_tags mltags = {0, 0};

-//static BOOL medialib_init = FALSE;

-//static char medialib_lastfn[2048] = "";

-//

-//__declspec(dllexport) int winampSetExtendedFileInfo(const char *fn, const char *data, char *val)

-//{

-//    int len, ret = 0;

-//    char *temp;

-//

-//    if (!medialib_init || (medialib_init && stricmp(fn, medialib_lastfn))) {

-//        MP4FileHandle file;

-//        strcpy(medialib_lastfn, fn);

-//

-//        if (medialib_init) tag_delete(&mltags);

-//

-//        file = MP4Read(fn, 0);

-//        if (file == MP4_INVALID_FILE_HANDLE) return 0;

-//        ReadMP4Tag(file, &mltags);

-//        MP4Close(file);

-//        medialib_init = TRUE;

-//    }

-//

-//    len = strlen(val);

-//    temp = (char *)malloc((len+1)*4);

-//    if (!temp) return 0;

-//

-//    if (ConvertANSIToUTF8(val, temp))

-//    {

-//        ret = 1;

-//        tag_set_field(&mltags, data, temp);

-//    }

-//

-//    free(temp);

-//

-//    return ret;

-//}    

-//

-//__declspec(dllexport) int winampWriteExtendedFileInfo()

-//{

-//    if (medialib_init)

-//    {

-//        MP4FileHandle file = MP4Modify(medialib_lastfn, 0, 0);

-//        if (file == MP4_INVALID_FILE_HANDLE) return 0;

-//

-//        MP4MetadataDelete(file);

-//        MP4Close(file);

-//

-//        file = MP4Modify(medialib_lastfn, 0, 0);

-//        if (file == MP4_INVALID_FILE_HANDLE) return 0;

-//

-//        WriteMP4Tag(file, &mltags);

-//

-//        MP4Close(file);

-//

-//        return 1;

-//    }

-//    else

-//    {

-//        return 0;

-//    }

-//}

diff --git a/faad2/src/plugins/QCDMp4/QCDMp4.rc b/faad2/src/plugins/QCDMp4/QCDMp4.rc
deleted file mode 100644
index 1ed6198..0000000
--- a/faad2/src/plugins/QCDMp4/QCDMp4.rc
+++ /dev/null
@@ -1,191 +0,0 @@
-// Microsoft Visual C++ generated resource script.

-//

-#include "resource.h"

-

-#define APSTUDIO_READONLY_SYMBOLS

-/////////////////////////////////////////////////////////////////////////////

-//

-// Generated from the TEXTINCLUDE 2 resource.

-//

-#include "afxres.h"

-

-/////////////////////////////////////////////////////////////////////////////

-#undef APSTUDIO_READONLY_SYMBOLS

-

-/////////////////////////////////////////////////////////////////////////////

-// ÖÐÎÄ(ÖлªÈËÃñ¹²ºÍ¹ú) resources

-

-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_CHS)

-#ifdef _WIN32

-LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED

-#pragma code_page(936)

-#endif //_WIN32

-

-/////////////////////////////////////////////////////////////////////////////

-//

-// Dialog

-//

-

-IDD_CONFIG DIALOGEX 0, 0, 242, 93

-STYLE DS_SETFONT | DS_MODALFRAME | WS_MINIMIZEBOX | WS_POPUP | WS_CAPTION | 

-    WS_SYSMENU

-CAPTION "Configuration"

-FONT 9, "ËÎÌå", 400, 0, 0x86

-BEGIN

-    CONTROL         "Slider1",IDC_PRIORITY,"msctls_trackbar32",TBS_VERT | 

-                    TBS_NOTICKS | WS_TABSTOP,13,15,18,46

-    CONTROL         "16 λ",IDC_16BITS,"Button",BS_AUTORADIOBUTTON,77,18,37,

-                    10

-    CONTROL         "16 λ¸ßƵ¶¶¶¯",IDC_16BITS_DITHERED,"Button",

-                    BS_AUTORADIOBUTTON | WS_DISABLED,77,29,64,10

-    CONTROL         "24 λ",IDC_24BITS,"Button",BS_AUTORADIOBUTTON,77,40,37,

-                    10

-    CONTROL         "32 λ",IDC_32BITS,"Button",BS_AUTORADIOBUTTON,77,51,37,

-                    10

-    CONTROL         "ÏòÏ»ìƵµ½Á¢ÌåÉù",IDC_DOWNMIX,"Button",BS_AUTOCHECKBOX | 

-                    WS_TABSTOP,152,13,80,10

-    CONTROL         "Ö§³Ö AAC ¸ñʽ",IDC_USEFORAAC,"Button",BS_AUTOCHECKBOX | 

-                    WS_TABSTOP,152,26,68,10

-    CONTROL         "ÏÔʾ¿É±ä±ÈÌØÂÊ",IDC_VBR,"Button",BS_AUTOCHECKBOX | 

-                    WS_TABSTOP,152,39,72,10

-    CONTROL         "ÏÔʾ´íÎóÐÅÏ¢",IDC_ERROR,"Button",BS_AUTOCHECKBOX | 

-                    WS_TABSTOP,152,52,64,10

-    DEFPUSHBUTTON   "È·¶¨",IDOK,185,72,50,14

-    PUSHBUTTON      "È¡Ïû",IDCANCEL,127,72,50,14

-    GROUPBOX        "ÓÅÏȼ¶",IDC_STATIC,7,7,57,58

-    LTEXT           "¸ß",IDC_STATIC,34,18,25,8

-    LTEXT           "±ê×¼",IDC_STATIC,34,35,23,8

-    LTEXT           "µÍ",IDC_STATIC,34,52,24,8

-    GROUPBOX        "½âÎö¶È",IDC_STATIC,71,7,73,58

-END

-

-

-/////////////////////////////////////////////////////////////////////////////

-//

-// DESIGNINFO

-//

-

-#ifdef APSTUDIO_INVOKED

-GUIDELINES DESIGNINFO 

-BEGIN

-    IDD_CONFIG, DIALOG

-    BEGIN

-        LEFTMARGIN, 7

-        RIGHTMARGIN, 235

-        TOPMARGIN, 7

-        BOTTOMMARGIN, 86

-    END

-END

-#endif    // APSTUDIO_INVOKED

-

-#endif    // ÖÐÎÄ(ÖлªÈËÃñ¹²ºÍ¹ú) resources

-/////////////////////////////////////////////////////////////////////////////

-

-

-/////////////////////////////////////////////////////////////////////////////

-// ºÉÀ¼Óï(ºÉÀ¼) resources

-

-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_NLD)

-#ifdef _WIN32

-LANGUAGE LANG_DUTCH, SUBLANG_DUTCH

-#pragma code_page(1252)

-#endif //_WIN32

-

-#ifdef APSTUDIO_INVOKED

-/////////////////////////////////////////////////////////////////////////////

-//

-// TEXTINCLUDE

-//

-

-1 TEXTINCLUDE 

-BEGIN

-    "resource.h\0"

-END

-

-2 TEXTINCLUDE 

-BEGIN

-    "#include ""afxres.h""\r\n"

-    "\0"

-END

-

-3 TEXTINCLUDE 

-BEGIN

-    "\r\n"

-    "\0"

-END

-

-#endif    // APSTUDIO_INVOKED

-

-

-/////////////////////////////////////////////////////////////////////////////

-//

-// Dialog

-//

-

-IDD_CONFIG DIALOGEX 0, 0, 233, 93

-STYLE DS_SETFONT | DS_MODALFRAME | WS_MINIMIZEBOX | WS_POPUP | WS_CAPTION | 

-    WS_SYSMENU

-CAPTION "Configuration"

-FONT 8, "MS Sans Serif", 0, 0, 0x0

-BEGIN

-    CONTROL         "Slider1",IDC_PRIORITY,"msctls_trackbar32",TBS_VERT | 

-                    TBS_NOTICKS | WS_TABSTOP,13,15,18,46

-    CONTROL         "16 bits",IDC_16BITS,"Button",BS_AUTORADIOBUTTON,77,18,

-                    37,10

-    CONTROL         "16 bits dithered",IDC_16BITS_DITHERED,"Button",

-                    BS_AUTORADIOBUTTON | WS_DISABLED,77,29,64,10

-    CONTROL         "24 bits",IDC_24BITS,"Button",BS_AUTORADIOBUTTON,77,40,

-                    37,10

-    CONTROL         "32 bits",IDC_32BITS,"Button",BS_AUTORADIOBUTTON,77,51,

-                    37,10

-    CONTROL         "Downmix to stereo",IDC_DOWNMIX,"Button",BS_AUTOCHECKBOX | 

-                    WS_TABSTOP,152,13,74,10

-    CONTROL         "Use for AAC",IDC_USEFORAAC,"Button",BS_AUTOCHECKBOX | 

-                    WS_TABSTOP,152,26,55,10

-    CONTROL         "VBR Display",IDC_VBR,"Button",BS_AUTOCHECKBOX | 

-                    WS_TABSTOP,152,39,55,10

-    CONTROL         "Show errors",IDC_ERROR,"Button",BS_AUTOCHECKBOX | 

-                    WS_TABSTOP,152,52,53,10

-    DEFPUSHBUTTON   "OK",IDOK,176,72,50,14

-    PUSHBUTTON      "Cancel",IDCANCEL,115,72,50,14

-    GROUPBOX        "Priority",IDC_STATIC,7,7,57,58

-    LTEXT           "Highest",IDC_STATIC,34,18,25,8

-    LTEXT           "Normal",IDC_STATIC,34,35,23,8

-    LTEXT           "Lowest",IDC_STATIC,34,52,24,8

-    GROUPBOX        "Resolution",IDC_STATIC,71,7,73,58

-END

-

-

-/////////////////////////////////////////////////////////////////////////////

-//

-// DESIGNINFO

-//

-

-#ifdef APSTUDIO_INVOKED

-GUIDELINES DESIGNINFO 

-BEGIN

-    IDD_CONFIG, DIALOG

-    BEGIN

-        LEFTMARGIN, 7

-        RIGHTMARGIN, 226

-        TOPMARGIN, 7

-        BOTTOMMARGIN, 86

-    END

-END

-#endif    // APSTUDIO_INVOKED

-

-#endif    // ºÉÀ¼Óï(ºÉÀ¼) resources

-/////////////////////////////////////////////////////////////////////////////

-

-

-

-#ifndef APSTUDIO_INVOKED

-/////////////////////////////////////////////////////////////////////////////

-//

-// Generated from the TEXTINCLUDE 3 resource.

-//

-

-

-/////////////////////////////////////////////////////////////////////////////

-#endif    // not APSTUDIO_INVOKED

-

diff --git a/faad2/src/plugins/QCDMp4/QCDMp4.sln b/faad2/src/plugins/QCDMp4/QCDMp4.sln
deleted file mode 100644
index 7167f45..0000000
--- a/faad2/src/plugins/QCDMp4/QCDMp4.sln
+++ /dev/null
@@ -1,35 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 9.00

-# Visual Studio 2005

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "QCDMp4", "QCDMp4.vcproj", "{2D8F479D-A591-4502-9456-398425D5F834}"

-	ProjectSection(ProjectDependencies) = postProject

-		{2398BB2F-FFF9-490B-B4CC-863F2D21AE46} = {2398BB2F-FFF9-490B-B4CC-863F2D21AE46}

-		{8CAC9E26-BAA5-45A4-8721-E3170B3F8F49} = {8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}

-	EndProjectSection

-EndProject

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libfaad", "..\..\libfaad\libfaad.vcproj", "{BC3EFE27-9015-4C9C-AD3C-72B3B7ED2114}"

-EndProject

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmp4v2_st", "..\..\common\mp4v2\libmp4v2_st60.vcproj", "{2398BB2F-FFF9-490B-B4CC-863F2D21AE46}"

-EndProject

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmp4av_st", "..\..\common\mp4av\libmp4av_st.vcproj", "{8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}"

-EndProject

-Global

-	GlobalSection(SolutionConfigurationPlatforms) = preSolution

-		Debug|Win32 = Debug|Win32

-		Release|Win32 = Release|Win32

-	EndGlobalSection

-	GlobalSection(ProjectConfigurationPlatforms) = postSolution

-		{2D8F479D-A591-4502-9456-398425D5F834}.Debug|Win32.ActiveCfg = Debug|Win32

-		{2D8F479D-A591-4502-9456-398425D5F834}.Debug|Win32.Build.0 = Debug|Win32

-		{2D8F479D-A591-4502-9456-398425D5F834}.Release|Win32.ActiveCfg = Release|Win32

-		{2D8F479D-A591-4502-9456-398425D5F834}.Release|Win32.Build.0 = Release|Win32

-		{BC3EFE27-9015-4C9C-AD3C-72B3B7ED2114}.Debug|Win32.ActiveCfg = Debug|Win32

-		{BC3EFE27-9015-4C9C-AD3C-72B3B7ED2114}.Release|Win32.ActiveCfg = Release|Win32

-		{2398BB2F-FFF9-490B-B4CC-863F2D21AE46}.Debug|Win32.ActiveCfg = Debug|Win32

-		{2398BB2F-FFF9-490B-B4CC-863F2D21AE46}.Release|Win32.ActiveCfg = Release|Win32

-		{8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}.Debug|Win32.ActiveCfg = Debug|Win32

-		{8CAC9E26-BAA5-45A4-8721-E3170B3F8F49}.Release|Win32.ActiveCfg = Release|Win32

-	EndGlobalSection

-	GlobalSection(SolutionProperties) = preSolution

-		HideSolutionNode = FALSE

-	EndGlobalSection

-EndGlobal

diff --git a/faad2/src/plugins/QCDMp4/QCDMp4.vcproj b/faad2/src/plugins/QCDMp4/QCDMp4.vcproj
deleted file mode 100644
index 2770362..0000000
--- a/faad2/src/plugins/QCDMp4/QCDMp4.vcproj
+++ /dev/null
@@ -1,285 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>

-<VisualStudioProject

-	ProjectType="Visual C++"

-	Version="8.00"

-	Name="QCDMp4"

-	ProjectGUID="{2D8F479D-A591-4502-9456-398425D5F834}"

-	>

-	<Platforms>

-		<Platform

-			Name="Win32"

-		/>

-	</Platforms>

-	<ToolFiles>

-	</ToolFiles>

-	<Configurations>

-		<Configuration

-			Name="Debug|Win32"

-			OutputDirectory=".\Debug"

-			IntermediateDirectory=".\Debug"

-			ConfigurationType="2"

-			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

-			UseOfMFC="0"

-			ATLMinimizesCRunTimeLibraryUsage="false"

-			>

-			<Tool

-				Name="VCPreBuildEventTool"

-			/>

-			<Tool

-				Name="VCCustomBuildTool"

-			/>

-			<Tool

-				Name="VCXMLDataGeneratorTool"

-			/>

-			<Tool

-				Name="VCWebServiceProxyGeneratorTool"

-			/>

-			<Tool

-				Name="VCMIDLTool"

-				PreprocessorDefinitions="_DEBUG"

-				MkTypLibCompatible="true"

-				SuppressStartupBanner="true"

-				TargetEnvironment="1"

-				TypeLibraryName=".\Debug/QCDMp4.tlb"

-			/>

-			<Tool

-				Name="VCCLCompilerTool"

-				Optimization="0"

-				AdditionalIncludeDirectories="..\..\include,..\..\common\mp4v2,..\..\common\mp4av"

-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS"

-				BasicRuntimeChecks="0"

-				RuntimeLibrary="1"

-				UsePrecompiledHeader="0"

-				PrecompiledHeaderFile=".\Debug/QCDMp4.pch"

-				AssemblerListingLocation=".\Debug/"

-				ObjectFile=".\Debug/"

-				ProgramDataBaseFileName=".\Debug/"

-				WarningLevel="3"

-				SuppressStartupBanner="true"

-				DebugInformationFormat="4"

-				CompileAs="0"

-			/>

-			<Tool

-				Name="VCManagedResourceCompilerTool"

-			/>

-			<Tool

-				Name="VCResourceCompilerTool"

-				PreprocessorDefinitions="_DEBUG"

-				Culture="1043"

-			/>

-			<Tool

-				Name="VCPreLinkEventTool"

-			/>

-			<Tool

-				Name="VCLinkerTool"

-				AdditionalOptions="/MACHINE:I386"

-				AdditionalDependencies="ws2_32.lib odbc32.lib odbccp32.lib"

-				OutputFile=".\Debug/QCDMp4.dll"

-				LinkIncremental="2"

-				SuppressStartupBanner="true"

-				GenerateDebugInformation="true"

-				ProgramDatabaseFile=".\Debug/QCDMp4.pdb"

-				SubSystem="2"

-				ImportLibrary=".\Debug/QCDMp4.lib"

-			/>

-			<Tool

-				Name="VCALinkTool"

-			/>

-			<Tool

-				Name="VCManifestTool"

-			/>

-			<Tool

-				Name="VCXDCMakeTool"

-			/>

-			<Tool

-				Name="VCBscMakeTool"

-			/>

-			<Tool

-				Name="VCFxCopTool"

-			/>

-			<Tool

-				Name="VCAppVerifierTool"

-			/>

-			<Tool

-				Name="VCWebDeploymentTool"

-			/>

-			<Tool

-				Name="VCPostBuildEventTool"

-			/>

-		</Configuration>

-		<Configuration

-			Name="Release|Win32"

-			OutputDirectory=".\Release"

-			IntermediateDirectory=".\Release"

-			ConfigurationType="2"

-			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

-			UseOfMFC="0"

-			ATLMinimizesCRunTimeLibraryUsage="false"

-			>

-			<Tool

-				Name="VCPreBuildEventTool"

-			/>

-			<Tool

-				Name="VCCustomBuildTool"

-			/>

-			<Tool

-				Name="VCXMLDataGeneratorTool"

-			/>

-			<Tool

-				Name="VCWebServiceProxyGeneratorTool"

-			/>

-			<Tool

-				Name="VCMIDLTool"

-				PreprocessorDefinitions="NDEBUG"

-				MkTypLibCompatible="true"

-				SuppressStartupBanner="true"

-				TargetEnvironment="1"

-				TypeLibraryName=".\Release/QCDMp4.tlb"

-			/>

-			<Tool

-				Name="VCCLCompilerTool"

-				Optimization="1"

-				InlineFunctionExpansion="1"

-				EnableIntrinsicFunctions="true"

-				FavorSizeOrSpeed="1"

-				AdditionalIncludeDirectories="..\..\include,..\..\common\mp4v2,..\..\common\mp4av"

-				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS"

-				StringPooling="true"

-				RuntimeLibrary="2"

-				EnableFunctionLevelLinking="true"

-				UsePrecompiledHeader="0"

-				PrecompiledHeaderFile=".\Release/QCDMp4.pch"

-				AssemblerListingLocation=".\Release/"

-				ObjectFile=".\Release/"

-				ProgramDataBaseFileName=".\Release/"

-				WarningLevel="3"

-				SuppressStartupBanner="true"

-				CompileAs="0"

-			/>

-			<Tool

-				Name="VCManagedResourceCompilerTool"

-			/>

-			<Tool

-				Name="VCResourceCompilerTool"

-				PreprocessorDefinitions="NDEBUG"

-				Culture="1043"

-			/>

-			<Tool

-				Name="VCPreLinkEventTool"

-			/>

-			<Tool

-				Name="VCLinkerTool"

-				AdditionalOptions="/MACHINE:I386"

-				AdditionalDependencies="ws2_32.lib"

-				OutputFile=".\Release/QCDMp4.dll"

-				LinkIncremental="1"

-				SuppressStartupBanner="true"

-				IgnoreDefaultLibraryNames=""

-				ProgramDatabaseFile=".\Release/QCDMp4.pdb"

-				SubSystem="2"

-				ImportLibrary=".\Release/QCDMp4.lib"

-			/>

-			<Tool

-				Name="VCALinkTool"

-			/>

-			<Tool

-				Name="VCManifestTool"

-			/>

-			<Tool

-				Name="VCXDCMakeTool"

-			/>

-			<Tool

-				Name="VCBscMakeTool"

-			/>

-			<Tool

-				Name="VCFxCopTool"

-			/>

-			<Tool

-				Name="VCAppVerifierTool"

-			/>

-			<Tool

-				Name="VCWebDeploymentTool"

-			/>

-			<Tool

-				Name="VCPostBuildEventTool"

-			/>

-		</Configuration>

-	</Configurations>

-	<References>

-	</References>

-	<Files>

-		<Filter

-			Name="Source Files"

-			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

-			>

-			<File

-				RelativePath=".\config.c"

-				>

-			</File>

-			<File

-				RelativePath=".\QCDMp4.c"

-				>

-			</File>

-			<File

-				RelativePath=".\QCDMp4Tag.cpp"

-				>

-			</File>

-			<File

-				RelativePath=".\utils.c"

-				>

-			</File>

-		</Filter>

-		<Filter

-			Name="Header Files"

-			Filter="h;hpp;hxx;hm;inl"

-			>

-			<File

-				RelativePath=".\config.h"

-				>

-			</File>

-			<File

-				RelativePath="..\..\include\faad.h"

-				>

-			</File>

-			<File

-				RelativePath=".\QCDInputDLL.h"

-				>

-			</File>

-			<File

-				RelativePath=".\QCDModDefs.h"

-				>

-			</File>

-			<File

-				RelativePath=".\QCDModInput.h"

-				>

-			</File>

-			<File

-				RelativePath=".\QCDModTagEditor.h"

-				>

-			</File>

-			<File

-				RelativePath=".\QCDTagsDLL.h"

-				>

-			</File>

-			<File

-				RelativePath="resource.h"

-				>

-			</File>

-			<File

-				RelativePath=".\utils.h"

-				>

-			</File>

-		</Filter>

-		<Filter

-			Name="Resource Files"

-			Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"

-			>

-			<File

-				RelativePath=".\QCDMp4.rc"

-				>

-			</File>

-		</Filter>

-	</Files>

-	<Globals>

-	</Globals>

-</VisualStudioProject>

diff --git a/faad2/src/plugins/QCDMp4/QCDMp4Tag.cpp b/faad2/src/plugins/QCDMp4/QCDMp4Tag.cpp
deleted file mode 100644
index 6fabbe1..0000000
--- a/faad2/src/plugins/QCDMp4/QCDMp4Tag.cpp
+++ /dev/null
@@ -1,839 +0,0 @@
-#include <mp4.h>

-#include <faad.h>

-#include "QCDTagsDLL.h"

-

-

-//..............................................................................

-// Global Variables

-

-typedef struct tag

-{

-    char *item;

-    char *value;

-} tag;

-

-typedef struct medialib_tags

-{

-    struct tag *tags;

-    unsigned int count;

-} medialib_tags;

-

-int tag_add_field(medialib_tags *tags, const char *item, const char *value)

-{

-    void *backup = (void *)tags->tags;

-

-    if (!item || (item && !*item) || !value) return 0;

-

-    tags->tags = (struct tag *)realloc(tags->tags, (tags->count+1) * sizeof(tag));

-    if (!tags->tags) {

-        if (backup) free(backup);

-        return 0;

-    }

-    else

-    {

-        int i_len = strlen(item);

-        int v_len = strlen(value);

-

-        tags->tags[tags->count].item = (char *)malloc(i_len+1);

-        tags->tags[tags->count].value = (char *)malloc(v_len+1);

-

-        if (!tags->tags[tags->count].item || !tags->tags[tags->count].value)

-        {

-            if (!tags->tags[tags->count].item) free (tags->tags[tags->count].item);

-            if (!tags->tags[tags->count].value) free (tags->tags[tags->count].value);

-            tags->tags[tags->count].item = NULL;

-            tags->tags[tags->count].value = NULL;

-            return 0;

-        }

-

-        memcpy(tags->tags[tags->count].item, item, i_len);

-        memcpy(tags->tags[tags->count].value, value, v_len);

-        tags->tags[tags->count].item[i_len] = '\0';

-        tags->tags[tags->count].value[v_len] = '\0';

-

-        tags->count++;

-        return 1;

-    }

-}

-

-int tag_set_field(medialib_tags *tags, const char *item, const char *value)

-{

-    unsigned int i;

-

-    if (!item || (item && !*item) || !value) return 0;

-

-    for (i = 0; i < tags->count; i++)

-    {

-        if (!stricmp(tags->tags[i].item, item))

-        {

-            void *backup = (void *)tags->tags[i].value;

-            int v_len = strlen(value);

-

-            tags->tags[i].value = (char *)realloc(tags->tags[i].value, v_len+1);

-            if (!tags->tags[i].value)

-            {

-                if (backup) free(backup);

-                return 0;

-            }

-

-            memcpy(tags->tags[i].value, value, v_len);

-            tags->tags[i].value[v_len] = '\0';

-

-            return 1;

-        }

-    }

-

-    return tag_add_field(tags, item, value);

-}

-

-void tag_delete(medialib_tags *tags)

-{

-    unsigned int i;

-

-    for (i = 0; i < tags->count; i++)

-    {

-        if (tags->tags[i].item) free(tags->tags[i].item);

-        if (tags->tags[i].value) free(tags->tags[i].value);

-    }

-

-    if (tags->tags) free(tags->tags);

-

-    tags->tags = NULL;

-    tags->count = 0;

-}

-

-int ReadMP4Tag(MP4FileHandle file, medialib_tags *tags)

-{

-    unsigned __int32 valueSize;

-    unsigned __int8 *pValue;

-    char *pName;

-    unsigned int i = 0;

-

-    do {

-        pName = 0;

-        pValue = 0;

-        valueSize = 0;

-

-        MP4GetMetadataByIndex(file, i, (const char **)&pName, &pValue, &valueSize);

-

-        if (valueSize > 0)

-        {

-            char *val = (char *)malloc(valueSize+1);

-            if (!val) return 0;

-            memcpy(val, pValue, valueSize);

-            val[valueSize] = '\0';

-

-            if (pName[0] == '\xa9')

-            {

-                if (memcmp(pName, "©nam", 4) == 0)

-                {

-                    tag_add_field(tags, "title", val);

-                } else if (memcmp(pName, "©ART", 4) == 0) {

-                    tag_add_field(tags, "artist", val);

-                } else if (memcmp(pName, "©wrt", 4) == 0) {

-                    tag_add_field(tags, "writer", val);

-                } else if (memcmp(pName, "©alb", 4) == 0) {

-                    tag_add_field(tags, "album", val);

-                } else if (memcmp(pName, "©day", 4) == 0) {

-                    tag_add_field(tags, "date", val);

-                } else if (memcmp(pName, "©too", 4) == 0) {

-                    tag_add_field(tags, "tool", val);

-                } else if (memcmp(pName, "©cmt", 4) == 0) {

-                    tag_add_field(tags, "comment", val);

-                } else if (memcmp(pName, "©gen", 4) == 0) {

-                    tag_add_field(tags, "genre", val);

-                } else {

-                    tag_add_field(tags, pName, val);

-                }

-            } else if (memcmp(pName, "gnre", 4) == 0) {

-                char *t=0;

-                if (MP4GetMetadataGenre(file, &t))

-                {

-                    tag_add_field(tags, "genre", t);

-                }

-            } else if (memcmp(pName, "trkn", 4) == 0) {

-                unsigned __int16 trkn = 0, tot = 0;

-                char t[200];

-                if (MP4GetMetadataTrack(file, &trkn, &tot))

-                {

-                    if (tot > 0)

-                        wsprintf(t, "%d/%d", trkn, tot);

-                    else

-                        wsprintf(t, "%d", trkn);

-                    tag_add_field(tags, "tracknumber", t);

-                }

-            } else if (memcmp(pName, "disk", 4) == 0) {

-                unsigned __int16 disk = 0, tot = 0;

-                char t[200];

-                if (MP4GetMetadataDisk(file, &disk, &tot))

-                {

-                    if (tot > 0)

-                        wsprintf(t, "%d/%d", disk, tot);

-                    else

-                        wsprintf(t, "%d", disk);

-                    tag_add_field(tags, "disc", t);

-                }

-            } else if (memcmp(pName, "cpil", 4) == 0) {

-                unsigned __int8 cpil = 0;

-                char t[200];

-                if (MP4GetMetadataCompilation(file, &cpil))

-                {

-                    wsprintf(t, "%d", cpil);

-                    tag_add_field(tags, "compilation", t);

-                }

-            } else if (memcmp(pName, "tmpo", 4) == 0) {

-                unsigned __int16 tempo = 0;

-                char t[200];

-                if (MP4GetMetadataTempo(file, &tempo))

-                {

-                    wsprintf(t, "%d BPM", tempo);

-                    tag_add_field(tags, "tempo", t);

-                }

-            } else if (memcmp(pName, "NDFL", 4) == 0) {

-                /* Removed */

-            } else {

-                tag_add_field(tags, pName, val);

-            }

-

-            free(val);

-        }

-

-        i++;

-    } while (valueSize > 0);

-

-    return 1;

-}

-

-int mp4_set_metadata(MP4FileHandle file, const char *item, const char *val)

-{

-    if (!item || (item && !*item) || !val || (val && !*val)) return 0;

-

-    if (!stricmp(item, "track") || !stricmp(item, "tracknumber"))

-    {

-        unsigned __int16 trkn, tot;

-        int t1 = 0, t2 = 0;

-        sscanf(val, "%d/%d", &t1, &t2);

-        trkn = t1, tot = t2;

-        if (!trkn) return 1;

-        if (MP4SetMetadataTrack(file, trkn, tot)) return 1;

-    }

-    else if (!stricmp(item, "disc") || !stricmp(item, "disknumber"))

-    {

-        unsigned __int16 disk, tot;

-        int t1 = 0, t2 = 0;

-        sscanf(val, "%d/%d", &t1, &t2);

-        disk = t1, tot = t2;

-        if (!disk) return 1;

-        if (MP4SetMetadataDisk(file, disk, tot)) return 1;

-    }

-    else if (!stricmp(item, "compilation"))

-    {

-        unsigned __int8 cpil = atoi(val);

-        if (!cpil) return 1;

-        if (MP4SetMetadataCompilation(file, cpil)) return 1;

-    }

-    else if (!stricmp(item, "tempo"))

-    {

-        unsigned __int16 tempo = atoi(val);

-        if (!tempo) return 1;

-        if (MP4SetMetadataTempo(file, tempo)) return 1;

-    }

-    else if (!stricmp(item, "artist"))

-    {

-        if (MP4SetMetadataArtist(file, val)) return 1;

-    }

-    else if (!stricmp(item, "writer"))

-    {

-        if (MP4SetMetadataWriter(file, val)) return 1;

-    }

-    else if (!stricmp(item, "title"))

-    {

-        if (MP4SetMetadataName(file, val)) return 1;

-    }

-    else if (!stricmp(item, "album"))

-    {

-        if (MP4SetMetadataAlbum(file, val)) return 1;

-    }

-    else if (!stricmp(item, "date") || !stricmp(item, "year"))

-    {

-        if (MP4SetMetadataYear(file, val)) return 1;

-    }

-    else if (!stricmp(item, "comment"))

-    {

-        if (MP4SetMetadataComment(file, val)) return 1;

-    }

-    else if (!stricmp(item, "genre"))

-    {

-        if (MP4SetMetadataGenre(file, val)) return 1;

-    }

-    else if (!stricmp(item, "tool"))

-    {

-        if (MP4SetMetadataTool(file, val)) return 1;

-    }

-    else

-    {

-        if (MP4SetMetadataFreeForm(file, (char *)item, (u_int8_t *)val, (u_int32_t)strlen(val) + 1)) return 1;

-    }

-

-    return 0;

-}

-

-void WriteMP4Tag(MP4FileHandle file, const medialib_tags *tags)

-{

-    unsigned int i;

-

-    for (i = 0; i < tags->count; i++)

-    {

-        const char *item = tags->tags[i].item;

-        const char *value = tags->tags[i].value;

-

-        if (value && *value)

-        {

-            mp4_set_metadata(file, item, value);

-        }

-    }

-}

-

-QCDModInitTag	ModInitTag;

-

-medialib_tags tags;

-

-BOOL uSetDlgItemText(void *tagHandle, int fieldId, const char *str);

-UINT uGetDlgItemText(void *tagHandle, int fieldId, char *str, int max);

-

-//------------------------------------------------------------------------------

-

-PLUGIN_API QCDModInitTag* TAGEDITORDLL_ENTRY_POINT()

-{	

-	ModInitTag.size			= sizeof(QCDModInitTag);

-	ModInitTag.version		= PLUGIN_API_VERSION;

-	ModInitTag.ShutDown		= ShutDown_Tag;

-

-	ModInitTag.Read			= Read_Tag;

-	ModInitTag.Write		= Write_Tag;	// Leave null for operations that plugin does not support

-	ModInitTag.Strip		= Strip_Tag;	// ie: if plugin only reads tags, leave Write and Strip null

-

-	ModInitTag.description	= "MP4 Tags";

-	ModInitTag.defaultexts	= "MP4:M4A";

-

-	return &ModInitTag;

-}

-

-//-----------------------------------------------------------------------------

-

-void ShutDown_Tag(int flags)

-{

-	// TODO:

-	// prepare plugin to be unloaded. All allocations should be freed.

-	// flags param is unused

-	tag_delete(&tags);

-}

-

-//-----------------------------------------------------------------------------

-

-bool Read_Tag(LPCSTR filename, void* tagHandle)

-{

-	// TODO:

-	// read metadata from tag and set each field to tagHandle

-	// only TAGFIELD_* are supported (see QCDModTagEditor.h)

-

-	// example of how to set value to tagHandle

-	// use SetFieldA for ASCII or MultiBytes strings.

-	// use SetFieldW for UNICODE strings

-	//

-	//	ModInitTag.SetFieldW(tagHandle, TAGFIELD_COMPOSER, szwValue);

-

-	// return true for successfull read, false for failure

-

-	MP4FileHandle file = MP4_INVALID_FILE_HANDLE;

-	char *pVal, dummy1[1024];

-	short dummy, dummy2;

-	u_int32_t valueSize = 0;

-

-#ifdef DEBUG_OUTPUT

-	in_mp4_DebugOutput("mp4_tag_read");

-#endif

-

-	file = MP4Read(filename, 0);

-

-	if (file == MP4_INVALID_FILE_HANDLE)

-		return false;

-

-	/* get Metadata */

-

-	pVal = NULL;

-	MP4GetMetadataName(file, &pVal);

-	uSetDlgItemText(tagHandle, TAGFIELD_TITLE, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataArtist(file, &pVal);

-	uSetDlgItemText(tagHandle, TAGFIELD_ARTIST, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataWriter(file, &pVal);

-	uSetDlgItemText(tagHandle, TAGFIELD_COMPOSER, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataComment(file, &pVal);

-	uSetDlgItemText(tagHandle, TAGFIELD_COMMENT, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataAlbum(file, &pVal);

-	uSetDlgItemText(tagHandle, TAGFIELD_ALBUM, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataGenre(file, &pVal);

-	uSetDlgItemText(tagHandle, TAGFIELD_GENRE, pVal);

-

-	//dummy = 0;

-	//MP4GetMetadataTempo(file, &dummy);

-	//if (dummy)

-	//{

-	//	wsprintf(dummy1, "%d", dummy);

-	//	SetDlgItemText(hwndDlg,IDC_METATEMPO, dummy1);

-	//}

-

-	dummy = 0; dummy2 = 0;

-	MP4GetMetadataTrack(file, (unsigned __int16*)&dummy, (unsigned __int16*)&dummy2);

-	if (dummy)

-	{

-		wsprintf(dummy1, "%d", dummy);

-		ModInitTag.SetFieldA(tagHandle, TAGFIELD_TRACK, dummy1);

-	}

-	//if (dumm2)

-	//{

-	//	wsprintf(dummy1, "%d", dummy2);

-	//	SetDlgItemText(hwndDlg,IDC_METATRACK2, dummy1);

-	//}

-

-	//dummy = 0; dummy2 = 0;

-	//MP4GetMetadataDisk(file, &dummy, &dummy2);

-	//if (dummy)

-	//{

-	//	wsprintf(dummy1, "%d", dummy);

-	//	SetDlgItemText(hwndDlg,IDC_METADISK1, dummy1);

-	//}

-	//if (dummy)

-	//{

-	//	wsprintf(dummy1, "%d", dummy2);

-	//	SetDlgItemText(hwndDlg,IDC_METADISK2, dummy1);

-	//}

-

-	pVal = NULL;

-	if (MP4GetMetadataYear(file, &pVal))

-		uSetDlgItemText(tagHandle, TAGFIELD_YEAR, pVal);

-

-	//dummy3 = 0;

-	//MP4GetMetadataCompilation(file, &dummy3);

-	//if (dummy3)

-	//	SendMessage(GetDlgItem(hwndDlg, IDC_METACOMPILATION), BM_SETCHECK, BST_CHECKED, 0);

-

-	pVal = NULL;

-	MP4GetMetadataTool(file, &pVal);

-	uSetDlgItemText(tagHandle, TAGFIELD_ENCODER, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataFreeForm(file, "CONDUCTOR", (unsigned __int8**)&pVal, &valueSize);

-	uSetDlgItemText(tagHandle, TAGFIELD_CONDUCTOR, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataFreeForm(file, "ORCHESTRA", (unsigned __int8**)&pVal, &valueSize);

-	uSetDlgItemText(tagHandle, TAGFIELD_ORCHESTRA, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataFreeForm(file, "YEARCOMPOSED", (unsigned __int8**)&pVal, &valueSize);

-	uSetDlgItemText(tagHandle, TAGFIELD_YEARCOMPOSED, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataFreeForm(file, "ORIGARTIST", (unsigned __int8**)&pVal, &valueSize);

-	uSetDlgItemText(tagHandle, TAGFIELD_ORIGARTIST, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataFreeForm(file, "LABEL", (unsigned __int8**)&pVal, &valueSize);

-	uSetDlgItemText(tagHandle, TAGFIELD_LABEL, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataFreeForm(file, "COPYRIGHT", (unsigned __int8**)&pVal, &valueSize);

-	uSetDlgItemText(tagHandle, TAGFIELD_COPYRIGHT, pVal);

-

-	pVal = NULL;

-	MP4GetMetadataFreeForm(file, "CDDBTAGID", (unsigned __int8**)&pVal, &valueSize);

-	uSetDlgItemText(tagHandle, TAGFIELD_CDDBTAGID, pVal);

-

-	/* ! Metadata */

-

-	MP4Close(file);

-

-	return true;

-}

-

-//-----------------------------------------------------------------------------

-

-bool Write_Tag(LPCSTR filename, void* tagHandle)

-{

-	// TODO:

-	// read metadata from tagHandle and set each field to supported tag

-	// only TAGFIELD_* are supported (see QCDModTagEditor.h)

-

-	// example of how to get value from tagHandle

-	// use SetFieldA for ASCII or MultiBytes strings.

-	// use SetFieldW for UNICODE strings

-	//

-	// szwValue = ModInitTag.GetFieldW(tagHandle, TAGFIELD_ORCHESTRA);

-

-	// write tag to file

-

-	MP4FileHandle file = MP4_INVALID_FILE_HANDLE;

-    char dummy1[1024];

-    char temp[1024];

-    short dummy, dummy2;

-

-#ifdef DEBUG_OUTPUT

-    in_mp4_DebugOutput("mp4_tag_write");

-#endif

-

-	/* save Metadata changes */

-

-	tag_delete(&tags);

-	file = MP4Read(filename, 0);

-	if (file != MP4_INVALID_FILE_HANDLE)

-	{

-		ReadMP4Tag(file, &tags);

-		MP4Close(file);

-

-		file = MP4Modify(filename, 0, 0);

-		if (file != MP4_INVALID_FILE_HANDLE)

-		{

-			MP4MetadataDelete(file);

-			MP4Close(file);

-		}

-	}

-

-	file = MP4Modify(filename, 0, 0);

-	if (file == MP4_INVALID_FILE_HANDLE)

-	{

-		tag_delete(&tags);

-		//EndDialog(hwndDlg, wParam);

-		return false;

-	}

-

-	uGetDlgItemText(tagHandle, TAGFIELD_TITLE, dummy1, 1024);

-	tag_set_field(&tags, "title", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_COMPOSER, dummy1, 1024);

-	tag_set_field(&tags, "writer", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_ARTIST, dummy1, 1024);

-	tag_set_field(&tags, "artist", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_ALBUM, dummy1, 1024);

-	tag_set_field(&tags, "album", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_COMMENT, dummy1, 1024);

-	tag_set_field(&tags, "comment", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_GENRE, dummy1, 1024);

-	tag_set_field(&tags, "genre", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_YEAR, dummy1, 1024);

-	tag_set_field(&tags, "year", dummy1);

-

-	dummy = 0;

-	MP4GetMetadataTrack(file, (unsigned __int16*)&dummy, (unsigned __int16*)&dummy2);

-	memcpy(dummy1, ModInitTag.GetFieldA(tagHandle, TAGFIELD_TRACK), sizeof(dummy1));

-	dummy = atoi(dummy1);

-	wsprintf(temp, "%d/%d", dummy, dummy2);

-	tag_set_field(&tags, "track", temp);

-

-	//GetDlgItemText(hwndDlg, IDC_METADISK1, dummy1, 1024);

-	//dummy = atoi(dummy1);

-	//GetDlgItemText(hwndDlg, IDC_METADISK2, dummy1, 1024);

-	//dummy2 = atoi(dummy1);

-	//wsprintf(temp, "%d/%d", dummy, dummy2);

-	//tag_set_field(&tags, "disc", temp);

-

-	//GetDlgItemText(hwndDlg, IDC_METATEMPO, dummy1, 1024);

-	//tag_set_field(&tags, "tempo", dummy1);

-

-	//dummy3 = SendMessage(GetDlgItem(hwndDlg, IDC_METACOMPILATION), BM_GETCHECK, 0, 0);

-	//tag_set_field(&tags, "compilation", (dummy3 ? "1" : "0"));

-

-	uGetDlgItemText(tagHandle, TAGFIELD_ENCODER, dummy1, 1024);

-	tag_set_field(&tags, "tool", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_CONDUCTOR, dummy1, 1024);

-	tag_set_field(&tags, "CONDUCTOR", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_ORCHESTRA, dummy1, 1024);

-	tag_set_field(&tags, "ORCHESTRA", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_YEARCOMPOSED, dummy1, 1024);

-	tag_set_field(&tags, "YEARCOMPOSED", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_ORIGARTIST, dummy1, 1024);

-	tag_set_field(&tags, "ORIGARTIST", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_LABEL, dummy1, 1024);

-	tag_set_field(&tags, "LABEL", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_COPYRIGHT, dummy1, 1024);

-	tag_set_field(&tags, "COPYRIGHT", dummy1);

-

-	uGetDlgItemText(tagHandle, TAGFIELD_CDDBTAGID, dummy1, 1024);

-	tag_set_field(&tags, "CDDBTAGID", dummy1);

-

-	WriteMP4Tag(file, &tags);

-

-	MP4Close(file);

-

-	MP4Optimize(filename, NULL, 0);

-	/* ! */

-

-	return true;

-}

-

-//-----------------------------------------------------------------------------

-

-bool Strip_Tag(LPCSTR filename)

-{

-	// TODO:

-	// remove tag from file.

-	// do whatever is need to remove the supported tag from filename

-

-	// return true for successfull strip, false for failure

-

-	MP4FileHandle file;

-

-	file = MP4Modify(filename, 0, 0);

-	if (file == MP4_INVALID_FILE_HANDLE)

-		return false;

-	

-	MP4MetadataDelete(file);

-

-	MP4Close(file);

-

-	return true;

-}

-

-//-----------------------------------------------------------------------------

-

-/* Convert UNICODE to UTF-8

-   Return number of bytes written */

-int unicodeToUtf8 ( const WCHAR* lpWideCharStr, char* lpMultiByteStr, int cwcChars )

-{

-    const unsigned short*   pwc = (unsigned short *)lpWideCharStr;

-    unsigned char*          pmb = (unsigned char  *)lpMultiByteStr;

-    const unsigned short*   pwce;

-    size_t  cBytes = 0;

-

-    if ( cwcChars >= 0 ) {

-        pwce = pwc + cwcChars;

-    } else {

-        pwce = (unsigned short *)((size_t)-1);

-    }

-

-    while ( pwc < pwce ) {

-        unsigned short  wc = *pwc++;

-

-        if ( wc < 0x00000080 ) {

-            *pmb++ = (char)wc;

-            cBytes++;

-        } else

-        if ( wc < 0x00000800 ) {

-            *pmb++ = (char)(0xC0 | ((wc >>  6) & 0x1F));

-            cBytes++;

-            *pmb++ = (char)(0x80 |  (wc        & 0x3F));

-            cBytes++;

-        } else

-        if ( wc < 0x00010000 ) {

-            *pmb++ = (char)(0xE0 | ((wc >> 12) & 0x0F));

-            cBytes++;

-            *pmb++ = (char)(0x80 | ((wc >>  6) & 0x3F));

-            cBytes++;

-            *pmb++ = (char)(0x80 |  (wc        & 0x3F));

-            cBytes++;

-        }

-        if ( wc == L'\0' )

-            return cBytes;

-    }

-

-    return cBytes;

-}

-

-/* Convert UTF-8 coded string to UNICODE

-   Return number of characters converted */

-int utf8ToUnicode ( const char* lpMultiByteStr, WCHAR* lpWideCharStr, int cmbChars )

-{

-    const unsigned char*    pmb = (unsigned char  *)lpMultiByteStr;

-    unsigned short*         pwc = (unsigned short *)lpWideCharStr;

-    const unsigned char*    pmbe;

-    size_t  cwChars = 0;

-

-    if ( cmbChars >= 0 ) {

-        pmbe = pmb + cmbChars;

-    } else {

-        pmbe = (unsigned char *)((size_t)-1);

-    }

-

-    while ( pmb < pmbe ) {

-        char            mb = *pmb++;

-        unsigned int    cc = 0;

-        unsigned int    wc;

-

-        while ( (cc < 7) && (mb & (1 << (7 - cc)))) {

-            cc++;

-        }

-

-        if ( cc == 1 || cc > 6 )                    // illegal character combination for UTF-8

-            continue;

-

-        if ( cc == 0 ) {

-            wc = mb;

-        } else {

-            wc = (mb & ((1 << (7 - cc)) - 1)) << ((cc - 1) * 6);

-            while ( --cc > 0 ) {

-                if ( pmb == pmbe )                  // reached end of the buffer

-                    return cwChars;

-                mb = *pmb++;

-                if ( ((mb >> 6) & 0x03) != 2 )      // not part of multibyte character

-                    return cwChars;

-                wc |= (mb & 0x3F) << ((cc - 1) * 6);

-            }

-        }

-

-        if ( wc & 0xFFFF0000 )

-            wc = L'?';

-        *pwc++ = wc;

-        cwChars++;

-        if ( wc == L'\0' )

-            return cwChars;

-    }

-

-    return cwChars;

-}

-

-/* convert Windows ANSI to UTF-8 */

-int ConvertANSIToUTF8 ( const char* ansi, char* utf8 )

-{

-    WCHAR*  wszValue;          // Unicode value

-    size_t  ansi_len;

-    size_t  len;

-

-    *utf8 = '\0';

-    if ( ansi == NULL )

-        return 0;

-

-    ansi_len = strlen ( ansi );

-

-    if ( (wszValue = (WCHAR *)malloc ( (ansi_len + 1) * 2 )) == NULL )

-        return 0;

-

-    /* Convert ANSI value to Unicode */

-    if ( (len = MultiByteToWideChar ( CP_ACP, 0, ansi, ansi_len + 1, wszValue, (ansi_len + 1) * 2 )) == 0 ) {

-        free ( wszValue );

-        return 0;

-    }

-

-    /* Convert Unicode value to UTF-8 */

-    if ( (len = unicodeToUtf8 ( wszValue, utf8, -1 )) == 0 ) {

-        free ( wszValue );

-        return 0;

-    }

-

-    free ( wszValue );

-

-    return len-1;

-}

-

-/* convert UTF-8 to Windows ANSI */

-int ConvertUTF8ToANSI ( const char* utf8, char* ansi )

-{

-    WCHAR*  wszValue;          // Unicode value

-    size_t  utf8_len;

-    size_t  len;

-

-    *ansi = '\0';

-    if ( utf8 == NULL )

-        return 0;

-

-    utf8_len = strlen ( utf8 );

-

-    if ( (wszValue = (WCHAR *)malloc ( (utf8_len + 1) * 2 )) == NULL )

-        return 0;

-

-    /* Convert UTF-8 value to Unicode */

-    if ( (len = utf8ToUnicode ( utf8, wszValue, utf8_len + 1 )) == 0 ) {

-        free ( wszValue );

-        return 0;

-    }

-

-    /* Convert Unicode value to ANSI */

-    if ( (len = WideCharToMultiByte ( CP_ACP, 0, wszValue, -1, ansi, (utf8_len + 1) * 2, NULL, NULL )) == 0 ) {

-        free ( wszValue );

-        return 0;

-    }

-

-    free ( wszValue );

-

-    return len-1;

-}

-

-BOOL uSetDlgItemText(void *tagHandle, int fieldId, const char *str)

-{

-    char *temp;

-    size_t len;

-    int r;

-

-    if (!str) return FALSE;

-	if (!*str) return FALSE;

-    len = strlen(str);

-    temp = (char *)malloc(len+1);

-    if (!temp) return FALSE;

-	memset(temp, '\0', len+1);

-    r = ConvertUTF8ToANSI(str, temp);

-    if (r > 0)

-        ModInitTag.SetFieldA(tagHandle, fieldId, temp);

-    free(temp);

-

-    return r>0 ? TRUE : FALSE;

-}

-

-UINT uGetDlgItemText(void *tagHandle, int fieldId, char *str, int max)

-{

-    char *temp, *utf8;;

-    int len;

-

-	const char *p;

-

-    if (!str || !max) return 0;

-    len = strlen( ModInitTag.GetFieldA(tagHandle, fieldId) );

-    temp = (char *)malloc(len+1);

-    if (!temp) return 0;

-    utf8 = (char *)malloc((len+1)*4);

-    if (!utf8)

-    {

-        free(temp);

-        return 0;

-    }

-

-	memset(temp, '\0', len+1);

-	memset(utf8, '\0', (len+1)*4);

-	memset(str, '\0', max);

-	p = ModInitTag.GetFieldA(tagHandle, fieldId);

-	memcpy(temp, p, len+1);

-    if (len > 0)

-    {

-        len = ConvertANSIToUTF8(temp, utf8);

-        if (len > max-1)

-        {

-            len = max-1;

-            utf8[max] = '\0';

-        }

-        memcpy(str, utf8, len+1);

-    }

-

-    free(temp);

-    free(utf8);

-

-    return len;

-}

diff --git a/faad2/src/plugins/QCDMp4/QCDTagsDLL.h b/faad2/src/plugins/QCDMp4/QCDTagsDLL.h
deleted file mode 100644
index d8621cc..0000000
--- a/faad2/src/plugins/QCDMp4/QCDTagsDLL.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef QCDTAGS_H

-#define QCDTAGS_H

-

-#include "QCDModTagEditor.h"

-

-extern HINSTANCE		hInstance;

-

-void ShutDown_Tag(int flags);

-bool Read_Tag(LPCSTR filename, void* tagData);

-bool Write_Tag(LPCSTR filename, void* tagData);

-bool Strip_Tag(LPCSTR filename);

-

-

-#endif
\ No newline at end of file
diff --git a/faad2/src/plugins/QCDMp4/aac2mp4.cpp b/faad2/src/plugins/QCDMp4/aac2mp4.cpp
deleted file mode 100644
index 8dd0811..0000000
--- a/faad2/src/plugins/QCDMp4/aac2mp4.cpp
+++ /dev/null
@@ -1,319 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: aac2mp4.cpp,v 1.3 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-#include <mpeg4ip.h>

-#include <mp4.h>

-#include <mp4av.h>

-

-#include "aac2mp4.h"

-

-int covert_aac_to_mp4(char *inputFileName, char *mp4FileName)

-{

-    int Mp4TimeScale = 90000;

-    int allMpeg4Streams = 0;

-    MP4FileHandle mp4File;

-    FILE* inFile;

-    const char *type;

-    MP4TrackId createdTrackId = MP4_INVALID_TRACK_ID;

-

-    mp4File = MP4Create(mp4FileName, 0, 0, 0);

-    if (mp4File)

-    {

-        MP4SetTimeScale(mp4File, Mp4TimeScale);

-    } else {

-        return 1;

-    }

-

-    inFile = fopen(inputFileName, "rb");

-

-	if (inFile == NULL)

-    {

-        MP4Close(mp4File);

-        return 2;

-    }

-

-    createdTrackId = AacCreator(mp4File, inFile);

-

-    if (createdTrackId == MP4_INVALID_TRACK_ID)

-    {

-        fclose(inFile);

-        MP4Close(mp4File);

-        return 3;

-    }

-

-    type = MP4GetTrackType(mp4File, createdTrackId);

-

-    if (!strcmp(type, MP4_AUDIO_TRACK_TYPE))

-    {

-        allMpeg4Streams &=

-            (MP4GetTrackAudioType(mp4File, createdTrackId)

-            == MP4_MPEG4_AUDIO_TYPE);

-    }

-

-    if (inFile)

-    {

-        fclose(inFile);

-    }

-

-    MP4Close(mp4File);

-    MP4MakeIsmaCompliant(mp4FileName, 0, allMpeg4Streams);

-

-    return 0;

-}

-

-#define ADTS_HEADER_MAX_SIZE 10 /* bytes */

-

-static u_int8_t firstHeader[ADTS_HEADER_MAX_SIZE];

-

-/* 

- * hdr must point to at least ADTS_HEADER_MAX_SIZE bytes of memory 

- */

-static bool LoadNextAdtsHeader(FILE* inFile, u_int8_t* hdr)

-{

-	u_int state = 0;

-	u_int dropped = 0;

-	u_int hdrByteSize = ADTS_HEADER_MAX_SIZE;

-

-	while (1) {

-		/* read a byte */

-		u_int8_t b;

-

-		if (fread(&b, 1, 1, inFile) == 0) {

-			return false;

-		}

-

-		/* header is complete, return it */

-		if (state == hdrByteSize - 1) {

-			hdr[state] = b;

-			if (dropped > 0) {

-				fprintf(stderr, "Warning: dropped %u input bytes\n", dropped);

-			}

-			return true;

-		}

-

-		/* collect requisite number of bytes, no constraints on data */

-		if (state >= 2) {

-			hdr[state++] = b;

-		} else {

-			/* have first byte, check if we have 1111X00X */

-			if (state == 1) {

-				if ((b & 0xF6) == 0xF0) {

-					hdr[state] = b;

-					state = 2;

-					/* compute desired header size */

-					hdrByteSize = MP4AV_AdtsGetHeaderByteSize(hdr);

-				} else {

-					state = 0;

-				}

-			}

-			/* initial state, looking for 11111111 */

-			if (state == 0) {

-				if (b == 0xFF) {

-					hdr[state] = b;

-					state = 1;

-				} else {

-					 /* else drop it */ 

-					dropped++;

-				}

-			}

-		}

-	}

-}

-

-/*

- * Load the next frame from the file

- * into the supplied buffer, which better be large enough!

- *

- * Note: Frames are padded to byte boundaries

- */

-static bool LoadNextAacFrame(FILE* inFile, u_int8_t* pBuf, u_int32_t* pBufSize, bool stripAdts)

-{

-	u_int16_t frameSize;

-	u_int16_t hdrBitSize, hdrByteSize;

-	u_int8_t hdrBuf[ADTS_HEADER_MAX_SIZE];

-

-	/* get the next AAC frame header, more or less */

-	if (!LoadNextAdtsHeader(inFile, hdrBuf)) {

-		return false;

-	}

-	

-	/* get frame size from header */

-	frameSize = MP4AV_AdtsGetFrameSize(hdrBuf);

-

-	/* get header size in bits and bytes from header */

-	hdrBitSize = MP4AV_AdtsGetHeaderBitSize(hdrBuf);

-	hdrByteSize = MP4AV_AdtsGetHeaderByteSize(hdrBuf);

-	

-	/* adjust the frame size to what remains to be read */

-	frameSize -= hdrByteSize;

-

-	if (stripAdts) {

-		if ((hdrBitSize % 8) == 0) {

-			/* header is byte aligned, i.e. MPEG-2 ADTS */

-			/* read the frame data into the buffer */

-			if (fread(pBuf, 1, frameSize, inFile) != frameSize) {

-				return false;

-			}

-			(*pBufSize) = frameSize;

-		} else {

-			/* header is not byte aligned, i.e. MPEG-4 ADTS */

-			int i;

-			u_int8_t newByte;

-			int upShift = hdrBitSize % 8;

-			int downShift = 8 - upShift;

-

-			pBuf[0] = hdrBuf[hdrBitSize / 8] << upShift;

-

-			for (i = 0; i < frameSize; i++) {

-				if (fread(&newByte, 1, 1, inFile) != 1) {

-					return false;

-				}

-				pBuf[i] |= (newByte >> downShift);

-				pBuf[i+1] = (newByte << upShift);

-			}

-			(*pBufSize) = frameSize + 1;

-		}

-	} else { /* don't strip ADTS headers */

-		memcpy(pBuf, hdrBuf, hdrByteSize);

-		if (fread(&pBuf[hdrByteSize], 1, frameSize, inFile) != frameSize) {

-			return false;

-		}

-	}

-

-	return true;

-}

-

-static bool GetFirstHeader(FILE* inFile)

-{

-	/* read file until we find an audio frame */

-	fpos_t curPos;

-

-	/* already read first header */

-	if (firstHeader[0] == 0xff) {

-		return true;

-	}

-

-	/* remember where we are */

-	fgetpos(inFile, &curPos);

-	

-	/* go back to start of file */

-	rewind(inFile);

-

-	if (!LoadNextAdtsHeader(inFile, firstHeader)) {

-		return false;

-	}

-

-	/* reposition the file to where we were */

-	fsetpos(inFile, &curPos);

-

-	return true;

-}

-

-MP4TrackId AacCreator(MP4FileHandle mp4File, FILE* inFile)

-{

-	// collect all the necessary meta information

-	u_int32_t samplesPerSecond;

-	u_int8_t mpegVersion;

-	u_int8_t profile;

-	u_int8_t channelConfig;

-

-	if (!GetFirstHeader(inFile)) {

-		return MP4_INVALID_TRACK_ID;

-	}

-

-	samplesPerSecond = MP4AV_AdtsGetSamplingRate(firstHeader);

-	mpegVersion = MP4AV_AdtsGetVersion(firstHeader);

-	profile = MP4AV_AdtsGetProfile(firstHeader);

-	channelConfig = MP4AV_AdtsGetChannels(firstHeader);

-

-	u_int8_t audioType = MP4_INVALID_AUDIO_TYPE;

-	switch (mpegVersion) {

-	case 0:

-		audioType = MP4_MPEG4_AUDIO_TYPE;

-		break;

-	case 1:

-		switch (profile) {

-		case 0:

-			audioType = MP4_MPEG2_AAC_MAIN_AUDIO_TYPE;

-			break;

-		case 1:

-			audioType = MP4_MPEG2_AAC_LC_AUDIO_TYPE;

-			break;

-		case 2:

-			audioType = MP4_MPEG2_AAC_SSR_AUDIO_TYPE;

-			break;

-		case 3:

-			return MP4_INVALID_TRACK_ID;

-		}

-		break;

-	}

-

-	// add the new audio track

-	MP4TrackId trackId = 

-		MP4AddAudioTrack(mp4File, 

-			samplesPerSecond, 1024, audioType);

-

-	if (trackId == MP4_INVALID_TRACK_ID) {

-		return MP4_INVALID_TRACK_ID;

-	}

-

-	if (MP4GetNumberOfTracks(mp4File, MP4_AUDIO_TRACK_TYPE) == 1) {

-		MP4SetAudioProfileLevel(mp4File, 0x0F);

-	}

-

-	u_int8_t* pConfig = NULL;

-	u_int32_t configLength = 0;

-

-	MP4AV_AacGetConfiguration(

-		&pConfig,

-		&configLength,

-		profile,

-		samplesPerSecond,

-		channelConfig);

-

-	if (!MP4SetTrackESConfiguration(mp4File, trackId, 

-	  pConfig, configLength)) {

-		MP4DeleteTrack(mp4File, trackId);

-		return MP4_INVALID_TRACK_ID;

-	}

-

-	// parse the ADTS frames, and write the MP4 samples

-	u_int8_t sampleBuffer[8 * 1024];

-	u_int32_t sampleSize = sizeof(sampleBuffer);

-	MP4SampleId sampleId = 1;

-

-	while (LoadNextAacFrame(inFile, sampleBuffer, &sampleSize, true)) {

-		if (!MP4WriteSample(mp4File, trackId, sampleBuffer, sampleSize)) {

-			MP4DeleteTrack(mp4File, trackId);

-			return MP4_INVALID_TRACK_ID;

-		}

-		sampleId++;

-		sampleSize = sizeof(sampleBuffer);

-	}

-

-	return trackId;

-}

diff --git a/faad2/src/plugins/QCDMp4/aac2mp4.h b/faad2/src/plugins/QCDMp4/aac2mp4.h
deleted file mode 100644
index b14913c..0000000
--- a/faad2/src/plugins/QCDMp4/aac2mp4.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: aac2mp4.h,v 1.3 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-#ifndef AAC2MP4_H__

-#define AAC2MP4_H__

-

-#ifdef __cplusplus

-extern "C" {

-#endif /* __cplusplus */

-

-int covert_aac_to_mp4(char *inputFileName, char *mp4FileName);

-MP4TrackId AacCreator(MP4FileHandle mp4File, FILE* inFile);

-

-#ifdef __cplusplus

-}

-#endif /* __cplusplus */

-

-#endif
\ No newline at end of file
diff --git a/faad2/src/plugins/QCDMp4/aacinfo.c b/faad2/src/plugins/QCDMp4/aacinfo.c
deleted file mode 100644
index fb689d6..0000000
--- a/faad2/src/plugins/QCDMp4/aacinfo.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: aacinfo.c,v 1.3 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-#define WIN32_LEAN_AND_MEAN

-#include <windows.h>

-#include <malloc.h>

-#include <stdlib.h>

-#include <stdio.h>

-#include "aacinfo.h"

-#include "utils.h"

-

-#define ADIF_MAX_SIZE 30 /* Should be enough */

-#define ADTS_MAX_SIZE 10 /* Should be enough */

-

-static int sample_rates[] = {96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000};

-

-static int read_ADIF_header(FILE *file, faadAACInfo *info)

-{

-    int bitstream;

-    unsigned char buffer[ADIF_MAX_SIZE];

-    int skip_size = 0;

-    int sf_idx;

-

-    /* Get ADIF header data */

-    info->headertype = 1;

-

-    if (fread(buffer, 1, ADIF_MAX_SIZE, file) != ADIF_MAX_SIZE)

-        return -1;

-

-    /* copyright string */

-    if(buffer[0] & 0x80)

-        skip_size += 9; /* skip 9 bytes */

-

-    bitstream = buffer[0 + skip_size] & 0x10;

-    info->bitrate = ((unsigned int)(buffer[0 + skip_size] & 0x0F)<<19)|

-        ((unsigned int)buffer[1 + skip_size]<<11)|

-        ((unsigned int)buffer[2 + skip_size]<<3)|

-        ((unsigned int)buffer[3 + skip_size] & 0xE0);

-

-    if (bitstream == 0)

-    {

-        info->object_type =  ((buffer[6 + skip_size]&0x01)<<1)|((buffer[7 + skip_size]&0x80)>>7);

-        sf_idx = (buffer[7 + skip_size]&0x78)>>3;

-    } else {

-        info->object_type = (buffer[4 + skip_size] & 0x18)>>3;

-        sf_idx = ((buffer[4 + skip_size] & 0x07)<<1)|((buffer[5 + skip_size] & 0x80)>>7);

-    }

-    info->sampling_rate = sample_rates[sf_idx];

-

-    return 0;

-}

-

-static int read_ADTS_header(FILE *file, faadAACInfo *info)

-{

-    /* Get ADTS header data */

-    unsigned char buffer[ADTS_MAX_SIZE];

-    int frames, t_framelength = 0, frame_length, sr_idx = 0, ID;

-    int second = 0, pos;

-    float frames_per_sec = 0;

-    unsigned long bytes;

-    unsigned long *tmp_seek_table = NULL;

-

-    info->headertype = 2;

-

-    /* Read all frames to ensure correct time and bitrate */

-    for (frames = 0; /* */; frames++)

-    {

-        bytes = fread(buffer, 1, ADTS_MAX_SIZE, file);

-

-        if (bytes != ADTS_MAX_SIZE)

-            break;

-

-        /* check syncword */

-        if (!((buffer[0] == 0xFF)&&((buffer[1] & 0xF6) == 0xF0)))

-            break;

-

-        if (!frames)

-        {

-            /* fixed ADTS header is the same for every frame, so we read it only once */

-            /* Syncword found, proceed to read in the fixed ADTS header */

-            ID = buffer[1] & 0x08;

-            info->object_type = (buffer[2]&0xC0)>>6;

-            sr_idx = (buffer[2]&0x3C)>>2;

-            info->channels = ((buffer[2]&0x01)<<2)|((buffer[3]&0xC0)>>6);

-

-            frames_per_sec = sample_rates[sr_idx] / 1024.f;

-        }

-

-        /* ...and the variable ADTS header */

-        if (ID == 0)

-        {

-            info->version = 4;

-        } else { /* MPEG-2 */

-            info->version = 2;

-        }

-        frame_length = ((((unsigned int)buffer[3] & 0x3)) << 11)

-            | (((unsigned int)buffer[4]) << 3) | (buffer[5] >> 5);

-

-        t_framelength += frame_length;

-

-        pos = ftell(file) - ADTS_MAX_SIZE;

-

-        fseek(file, frame_length - ADTS_MAX_SIZE, SEEK_CUR);

-    }

-

-    if (frames > 0)

-    {

-        float sec_per_frame, bytes_per_frame;

-        info->sampling_rate = sample_rates[sr_idx];

-        sec_per_frame = (float)info->sampling_rate/1024.0;

-        bytes_per_frame = (float)t_framelength / (float)frames;

-        info->bitrate = 8 * (int)floor(bytes_per_frame * sec_per_frame);

-        info->length = (int)floor((float)frames/frames_per_sec)*1000;

-    } else {

-        info->sampling_rate = 4;

-        info->bitrate = 128000;

-        info->length = 0;

-        info->channels = 0;

-    }

-

-    return 0;

-}

-

-int get_AAC_format(char *filename, faadAACInfo *info)

-{

-    unsigned long tagsize;

-    FILE *file;

-    char buffer[10];

-    unsigned long file_len;

-    unsigned char adxx_id[5];

-    unsigned long tmp;

-

-    memset(info, 0, sizeof(faadAACInfo));

-

-    file = fopen(filename, "rb");

-

-    if(file == NULL)

-        return -1;

-

-    fseek(file, 0, SEEK_END);

-    file_len = ftell(file);

-    fseek(file, 0, SEEK_SET);

-

-    /* Skip the tag, if it's there */

-    tmp = fread(buffer, 10, 1, file);

-

-    if (StringComp(buffer, "ID3", 3) == 0)

-    {

-        /* high bit is not used */

-        tagsize = (buffer[6] << 21) | (buffer[7] << 14) |

-            (buffer[8] <<  7) | (buffer[9] <<  0);

-

-        fseek(file, tagsize, SEEK_CUR);

-        tagsize += 10;

-    } else {

-        tagsize = 0;

-        fseek(file, 0, SEEK_SET);

-    }

-

-    if (file_len)

-        file_len -= tagsize;

-

-    tmp = fread(adxx_id, 2, 1, file);

-    adxx_id[5-1] = 0;

-    info->length = 0;

-

-    /* Determine the header type of the file, check the first two bytes */

-    if (StringComp(adxx_id, "AD", 2) == 0)

-    {

-        /* We think its an ADIF header, but check the rest just to make sure */

-        tmp = fread(adxx_id + 2, 2, 1, file);

-

-        if (StringComp(adxx_id, "ADIF", 4) == 0)

-        {

-            read_ADIF_header(file, info);

-

-            info->length = (int)((float)file_len*8000.0/((float)info->bitrate));

-        }

-    } else {

-        /* No ADIF, check for ADTS header */

-        if ((adxx_id[0] == 0xFF)&&((adxx_id[1] & 0xF6) == 0xF0))

-        {

-            /* ADTS  header located */

-            fseek(file, tagsize, SEEK_SET);

-            read_ADTS_header(file, info);

-        } else {

-            /* Unknown/headerless AAC file, assume format: */

-            info->version = 2;

-            info->bitrate = 128000;

-            info->sampling_rate = 44100;

-            info->channels = 2;

-            info->headertype = 0;

-            info->object_type = 1;

-        }

-    }

-

-    fclose(file);

-

-    return 0;

-}

diff --git a/faad2/src/plugins/QCDMp4/aacinfo.h b/faad2/src/plugins/QCDMp4/aacinfo.h
deleted file mode 100644
index 867fef9..0000000
--- a/faad2/src/plugins/QCDMp4/aacinfo.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: aacinfo.h,v 1.3 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-#ifndef AACINFO_INCLUDED

-#define AACINFO_INCLUDED

-

-typedef struct {

-    int version;

-    int channels;

-    int sampling_rate;

-    int bitrate;

-    int length;

-    int object_type;

-    int headertype;

-} faadAACInfo;

-

-int get_AAC_format(char *filename, faadAACInfo *info);

-

-static int read_ADIF_header(FILE *file, faadAACInfo *info);

-static int read_ADTS_header(FILE *file, faadAACInfo *info);

-

-#endif

diff --git a/faad2/src/plugins/QCDMp4/config.c b/faad2/src/plugins/QCDMp4/config.c
deleted file mode 100644
index af5af5a..0000000
--- a/faad2/src/plugins/QCDMp4/config.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: config.c,v 1.3 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-#define WIN32_LEAN_AND_MEAN

-#include <windows.h>

-#include "config.h"

-

-char app_name[] = "AudioCoding.com MPEG-4 General Audio player";

-char INI_FILE[MAX_PATH];

-int m_priority = 3;

-int m_resolution = 0;

-int m_show_errors = 1;

-int m_use_for_aac = 1;

-int m_downmix = 0;

-int m_vbr_display = 0;

-char titleformat[MAX_PATH];

-

-void _r_s(char *name,char *data, int mlen)

-{

-	char buf[10];

-	strcpy(buf,data);

-	GetPrivateProfileString(app_name,name,buf,data,mlen,INI_FILE);

-}

-

diff --git a/faad2/src/plugins/QCDMp4/config.h b/faad2/src/plugins/QCDMp4/config.h
deleted file mode 100644
index 93f6d71..0000000
--- a/faad2/src/plugins/QCDMp4/config.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: config.h,v 1.3 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-char app_name[];

-char INI_FILE[];

-int m_priority;

-int m_resolution;

-int m_show_errors;

-int m_use_for_aac;

-int m_downmix;

-int m_vbr_display;

-char titleformat[MAX_PATH];

-

-#define RS(x) (_r_s(#x,x,sizeof(x)))

-#define WS(x) (WritePrivateProfileString(app_name,#x,x,INI_FILE))

-

-void _r_s(char *name,char *data, int mlen);

-

diff --git a/faad2/src/plugins/QCDMp4/mbs.h b/faad2/src/plugins/QCDMp4/mbs.h
deleted file mode 100644
index bda58ed..0000000
--- a/faad2/src/plugins/QCDMp4/mbs.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*

- * The contents of this file are subject to the Mozilla Public

- * License Version 1.1 (the "License"); you may not use this file

- * except in compliance with the License. You may obtain a copy of

- * the License at http://www.mozilla.org/MPL/

- * 

- * Software distributed under the License is distributed on an "AS

- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

- * implied. See the License for the specific language governing

- * rights and limitations under the License.

- * 

- * The Original Code is MPEG4IP.

- * 

- * The Initial Developer of the Original Code is Cisco Systems Inc.

- * Portions created by Cisco Systems Inc. are

- * Copyright (C) Cisco Systems Inc. 2001-2002.  All Rights Reserved.

- * 

- * Contributor(s): 

- *		Dave Mackie		dmackie@cisco.com

- */

-

-#ifndef __MBS_INCLUDED__

-#define __MBS_INCLUDED__ 

-

-class CMemoryBitstream {

-public:

-	CMemoryBitstream() {

-		m_pBuf = NULL;

-		m_bitPos = 0;

-		m_numBits = 0;

-	}

-

-	void AllocBytes(u_int32_t numBytes);

-

-	void SetBytes(u_int8_t* pBytes, u_int32_t numBytes);

-

-	void PutBytes(u_int8_t* pBytes, u_int32_t numBytes);

-

-	void PutBits(u_int32_t bits, u_int32_t numBits);

-

-	u_int32_t GetBits(u_int32_t numBits);

-

-	void SkipBytes(u_int32_t numBytes) {

-		SkipBits(numBytes << 3);

-	}

-

-	void SkipBits(u_int32_t numBits) {

-		SetBitPosition(GetBitPosition() + numBits);

-	}

-

-	u_int32_t GetBitPosition() {

-		return m_bitPos;

-	}

-

-	void SetBitPosition(u_int32_t bitPos) {

-		if (bitPos > m_numBits) {

-			throw;

-		}

-		m_bitPos = bitPos;

-	}

-

-	u_int8_t* GetBuffer() {

-		return m_pBuf;

-	}

-

-	u_int32_t GetNumberOfBytes() {

-		return (GetNumberOfBits() + 7) / 8;

-	}

-

-	u_int32_t GetNumberOfBits() {

-		return m_numBits;

-	}

-

-protected:

-	u_int8_t*	m_pBuf;

-	u_int32_t	m_bitPos;

-	u_int32_t	m_numBits;

-};

-

-#endif /* __MBS_INCLUDED__ */ 

-

diff --git a/faad2/src/plugins/QCDMp4/resource.h b/faad2/src/plugins/QCDMp4/resource.h
deleted file mode 100644
index e04de22..0000000
--- a/faad2/src/plugins/QCDMp4/resource.h
+++ /dev/null
@@ -1,67 +0,0 @@
-//{{NO_DEPENDENCIES}}

-// Microsoft Visual C++ generated include file.

-// Used by QCDMp4.rc

-//

-#define IDD_CONFIG                      102

-#define IDC_TYPE                        1000

-#define IDC_INFOTEXT                    1000

-#define IDC_DURATION                    1001

-#define IDC_BITRATE                     1002

-#define IDC_SAMPLERATE                  1003

-#define IDC_VTYPE                       1004

-#define IDC_PRIORITY                    1004

-#define IDC_VBITRATE                    1005

-#define IDC_ERROR                       1005

-#define IDC_VDURATION                   1006

-#define IDC_16BITS                      1006

-#define IDC_VSIZE                       1007

-#define IDC_24BITS                      1007

-#define IDC_CONVERT                     1007

-#define IDC_VFPS                        1008

-#define IDC_32BITS                      1008

-#define IDC_CONVERT2                    1008

-#define IDC_CHANNELS                    1009

-#define IDC_24BITS2                     1009

-#define IDC_16BITS_DITHERED             1009

-#define IDC_CONVERT1                    1009

-#define IDC_USERDATA                    1010

-#define IDC_USEFORAAC                   1011

-#define IDC_METACOMPILATION             1012

-#define IDC_METANAME                    1013

-#define IDC_METAARTIST                  1014

-#define IDC_METAWRITER                  1015

-#define IDC_METAALBUM                   1016

-#define IDC_METACOMMENTS                1017

-#define IDC_METAGENRE                   1018

-#define IDC_METAYEAR                    1019

-#define IDC_METATRACK1                  1020

-#define IDC_METADISK1                   1021

-#define IDC_METATEMPO                   1022

-#define IDC_METATRACK2                  1023

-#define IDC_METADISK2                   1024

-#define IDC_STATIC1                     1025

-#define IDC_STATIC2                     1026

-#define IDC_STATIC3                     1027

-#define IDC_STATIC4                     1028

-#define IDC_STATIC5                     1029

-#define IDC_STATIC6                     1030

-#define IDC_STATIC7                     1031

-#define IDC_STATIC8                     1032

-#define IDC_STATIC9                     1033

-#define IDC_STATIC10                    1034

-#define IDC_STATIC11                    1035

-#define IDC_STATIC12                    1036

-#define IDC_DOWNMIX                     1038

-#define IDC_VBR                         1039

-#define IDC_TITLEFORMAT                 1040

-

-// Next default values for new objects

-// 

-#ifdef APSTUDIO_INVOKED

-#ifndef APSTUDIO_READONLY_SYMBOLS

-#define _APS_NEXT_RESOURCE_VALUE        103

-#define _APS_NEXT_COMMAND_VALUE         40001

-#define _APS_NEXT_CONTROL_VALUE         1041

-#define _APS_NEXT_SYMED_VALUE           101

-#endif

-#endif

diff --git a/faad2/src/plugins/QCDMp4/utils.c b/faad2/src/plugins/QCDMp4/utils.c
deleted file mode 100644
index 9302de6..0000000
--- a/faad2/src/plugins/QCDMp4/utils.c
+++ /dev/null
@@ -1,153 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: utils.c,v 1.3 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-#define WIN32_LEAN_AND_MEAN

-#include <windows.h>

-#include <mp4.h>

-#include <faad.h>

-#include "utils.h"

-

-int StringComp(char const *str1, char const *str2, unsigned long len)

-{

-    signed int c1 = 0, c2 = 0;

-

-    while (len--)

-    {

-        c1 = tolower(*str1++);

-        c2 = tolower(*str2++);

-

-        if (c1 == 0 || c1 != c2)

-            break;

-    }

-

-    return c1 - c2;

-}

-

-int GetAACTrack(MP4FileHandle infile)

-{

-    /* find AAC track */

-    int i, rc;

-	int numTracks = MP4GetNumberOfTracks(infile, NULL, 0);

-

-	for (i = 0; i < numTracks; i++)

-    {

-        MP4TrackId trackId = MP4FindTrackId(infile, i, NULL, 0);

-        const char* trackType = MP4GetTrackType(infile, trackId);

-

-        if (!strcmp(trackType, MP4_AUDIO_TRACK_TYPE))

-        {

-            unsigned char *buff = NULL;

-            int buff_size = 0;

-            mp4AudioSpecificConfig mp4ASC;

-

-            MP4GetTrackESConfiguration(infile, trackId, &buff, &buff_size);

-

-            if (buff)

-            {

-                rc = AudioSpecificConfig(buff, buff_size, &mp4ASC);

-                free(buff);

-

-                if (rc < 0)

-                    return -1;

-                return trackId;

-            }

-        }

-    }

-

-    /* can't decode this */

-    return -1;

-}

-

-int GetAudioTrack(MP4FileHandle infile)

-{

-    /* find AAC track */

-    int i;

-	int numTracks = MP4GetNumberOfTracks(infile, NULL, 0);

-

-	for (i = 0; i < numTracks; i++)

-    {

-        MP4TrackId trackId = MP4FindTrackId(infile, i, NULL, 0);

-        const char* trackType = MP4GetTrackType(infile, trackId);

-

-        if (!strcmp(trackType, MP4_AUDIO_TRACK_TYPE))

-        {

-            return trackId;

-        }

-    }

-

-    /* can't decode this */

-    return -1;

-}

-

-int GetVideoTrack(MP4FileHandle infile)

-{

-    /* find AAC track */

-    int i;

-	int numTracks = MP4GetNumberOfTracks(infile, NULL, 0);

-

-	for (i = 0; i < numTracks; i++)

-    {

-        MP4TrackId trackId = MP4FindTrackId(infile, i, NULL, 0);

-        const char* trackType = MP4GetTrackType(infile, trackId);

-

-        if (!strcmp(trackType, MP4_VIDEO_TRACK_TYPE))

-        {

-            return trackId;

-        }

-    }

-

-    /* can't decode this */

-    return -1;

-}

-

-LPTSTR PathFindFileName(LPCTSTR pPath)

-{

-    LPCTSTR pT;

-

-    for (pT = pPath; *pPath; pPath = CharNext(pPath)) {

-        if ((pPath[0] == TEXT('\\') || pPath[0] == TEXT(':')) && pPath[1] && (pPath[1] != TEXT('\\')))

-            pT = pPath + 1;

-    }

-

-    return (LPTSTR)pT;   // const -> non const

-}

-

-char *convert3in4to3in3(void *sample_buffer, int samples)

-{

-    int i;

-    long *sample_buffer24 = (long*)sample_buffer;

-    char *data = malloc(samples*3*sizeof(char));

-

-    for (i = 0; i < samples; i++)

-    {

-        data[i*3] = sample_buffer24[i] & 0xFF;

-        data[i*3+1] = (sample_buffer24[i] >> 8) & 0xFF;

-        data[i*3+2] = (sample_buffer24[i] >> 16) & 0xFF;

-    }

-

-    return data;

-}

diff --git a/faad2/src/plugins/QCDMp4/utils.h b/faad2/src/plugins/QCDMp4/utils.h
deleted file mode 100644
index 494e019..0000000
--- a/faad2/src/plugins/QCDMp4/utils.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*

-** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding

-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-**

-** Any non-GPL usage of this software or parts of this software is strictly

-** forbidden.

-**

-** Commercial non-GPL licensing of this software is possible.

-** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

-**

-** $Id: utils.h,v 1.3 2003/12/06 04:24:17 rjamorim Exp $

-**/

-

-#ifndef UTILS_INCLUDED

-#define UTILS_INCLUDED

-

-#include <mp4.h>

-

-LPTSTR PathFindFileName(LPCTSTR pPath);

-int GetVideoTrack(MP4FileHandle infile);

-int GetAudioTrack(MP4FileHandle infile);

-int GetAACTrack(MP4FileHandle infile);

-int StringComp(char const *str1, char const *str2, unsigned long len);

-char *convert3in4to3in3(void *sample_buffer, int samples);

-

-#endif
\ No newline at end of file