fteqw/engine/client/m_mp3.c

//mp3 menu and track selector.
//was origonally an mp3 track selector, now handles lots of media specific stuff - like q3 films!
//should rename to m_media.c
#include "quakedef.h"

#ifdef GLQUAKE
#include "glquake.h"
#endif
#ifdef VKQUAKE
#include "../vk/vkrenderer.h"
#endif
#include "shader.h"
#include "gl_draw.h"

#if defined(HAVE_JUKEBOX)
	#if defined(_WIN32) && !defined(WINRT) && !defined(NOMEDIAMENU)
		//#define WINAMP
	#endif
#endif
#if (defined(HAVE_MEDIA_DECODER) || defined(HAVE_MEDIA_ENCODER)) && defined(_WIN32) && !defined(WINRT)
	#define HAVE_API_VFW
#endif

#ifdef _WIN32
	#include "winquake.h"
#endif
#if defined(AVAIL_MP3_ACM) || defined(HAVE_API_VFW)
//equivelent to
//#include <msacm.h>
#undef CDECL	//windows is stupid at times.
#define CDECL __cdecl

#if defined(_MSC_VER) && (_MSC_VER < 1300)
	#define DWORD_PTR DWORD
#endif

DECLARE_HANDLE(HACMSTREAM);
typedef HACMSTREAM *LPHACMSTREAM;
DECLARE_HANDLE(HACMDRIVER);
typedef struct {
	DWORD     cbStruct;
	DWORD     fdwStatus;
	DWORD_PTR dwUser;
	LPBYTE    pbSrc;
	DWORD     cbSrcLength;
	DWORD     cbSrcLengthUsed;
	DWORD_PTR dwSrcUser;
	LPBYTE    pbDst;
	DWORD     cbDstLength;
	DWORD     cbDstLengthUsed;
	DWORD_PTR dwDstUser;
	DWORD     dwReservedDriver[10];
} ACMSTREAMHEADER, *LPACMSTREAMHEADER;
#define ACM_STREAMCONVERTF_BLOCKALIGN   0x00000004




//mingw workarounds
#define LPWAVEFILTER void *
#include <objbase.h>

MMRESULT (WINAPI *qacmStreamUnprepareHeader) (HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwUnprepare);
MMRESULT (WINAPI *qacmStreamConvert) (HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwConvert);
MMRESULT (WINAPI *qacmStreamPrepareHeader) (HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwPrepare);
MMRESULT (WINAPI *qacmStreamOpen) (LPHACMSTREAM phas, HACMDRIVER had, LPWAVEFORMATEX pwfxSrc, LPWAVEFORMATEX pwfxDst, LPWAVEFILTER pwfltr, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
MMRESULT (WINAPI *qacmStreamClose) (HACMSTREAM has, DWORD fdwClose);

static qboolean qacmStartup(void)
{
	static int inited;
	static dllhandle_t *module;
	if (!inited)
	{
		dllfunction_t funcs[] =
		{
			{(void*)&qacmStreamUnprepareHeader,	"acmStreamUnprepareHeader"},
			{(void*)&qacmStreamConvert,			"acmStreamConvert"},
			{(void*)&qacmStreamPrepareHeader,	"acmStreamPrepareHeader"},
			{(void*)&qacmStreamOpen,			"acmStreamOpen"},
			{(void*)&qacmStreamClose,			"acmStreamClose"},
			{NULL,NULL}
		};
		inited = true;
		module = Sys_LoadLibrary("msacm32.dll", funcs);
	}

	return module?true:false;
}
#endif

static char media_currenttrack[MAX_QPATH];
static cvar_t music_fade = CVAR("music_fade", "1");

//higher bits have priority (if they have something to play).
#define MEDIA_GAMEMUSIC (1u<<0)	//cd music. also music command etc.
#ifdef HAVE_JUKEBOX
#define MEDIA_CVARLIST	(1u<<1)	//cvar abuse. handy for preserving times when switching tracks.
#define MEDIA_PLAYLIST	(1u<<2)	//
static unsigned int media_playlisttypes;
static unsigned int media_playlistcurrent;

//cvar abuse
static int music_playlist_last;
static cvar_t music_playlist_index = CVAR("music_playlist_index", "-1");
//	created dynamically: CVAR("music_playlist_list0+", ""),
//	created dynamically: CVAR("music_playlist_sampleposition0+", "-1"),


typedef struct mediatrack_s{
	char filename[MAX_QPATH];
	char nicename[MAX_QPATH];
	int length;
	struct mediatrack_s *next;
} mediatrack_t;

//info about the current stuff that is playing.
static char media_friendlyname[MAX_QPATH];



int lasttrackplayed;

cvar_t media_shuffle = CVAR("media_shuffle", "1");
cvar_t media_repeat = CVAR("media_repeat", "1");
#ifdef WINAMP
cvar_t media_hijackwinamp = CVAR("media_hijackwinamp", "0");
#endif

int selectedoption=-1;
static int mouseselectedoption=-1;
int numtracks;
int nexttrack=-1;
mediatrack_t *tracks;

char media_iofilename[MAX_OSPATH]="";

#if !defined(NOMEDIAMENU) && !defined(NOBUILTINMENUS)
void Media_LoadTrackNames (char *listname);
void Media_SaveTrackNames (char *listname);
int loadedtracknames;
#endif
qboolean Media_EvaluateNextTrack(void);

#else
#define NOMEDIAMENU	//the media menu requires us to be able to queue up random tracks and stuff.
#endif

#ifdef HAVE_CDPLAYER
static int cdplayingtrack;	//currently playing cd track (becomes 0 when paused)
static int cdpausedtrack;	//currently paused cd track

//info about (fake)cd tracks that we want to play
int cdplaytracknum;

//info about (fake)cd tracks that we could play if asked.
#define REMAPPED_TRACKS 256
static struct
{
	char fname[MAX_QPATH];
} cdremap[REMAPPED_TRACKS];
static qboolean cdenabled;
static int cdnumtracks;		//maximum cd track we can play.
#endif


static char media_playtrack[MAX_QPATH];		//name of track to play next/now
static char media_loopingtrack[MAX_QPATH];	//name of track to loop afterwards
qboolean media_fadeout;
float media_fadeouttime;

//whatever music track was previously playing has terminated.
//return value is the new sample to start playing.
//*starttime says the time into the track that we should resume playing at
//this is on the main thread with the mixer locked, its safe to do stuff, but try not to block
sfx_t *Media_NextTrack(int musicchannelnum, float *starttime)
{
	sfx_t *s = NULL;
	if (bgmvolume.value <= 0)
		return NULL;

	if (media_fadeout)
	{
		if (S_Music_Playing(musicchannelnum))
			return NULL;	//can't pick a new track until they've all stopped.

		//okay, it has actually stopped everywhere.
	}
	media_fadeout = false;	//it has actually ended now

	Q_strncpyz(media_currenttrack, "", sizeof(media_currenttrack));
#ifdef HAVE_JUKEBOX
	Q_strncpyz(media_friendlyname, "", sizeof(media_friendlyname));

	music_playlist_index.modified = false;
	music_playlist_last = -1;
	media_playlistcurrent = 0;

	if (!media_playlistcurrent && (media_playlisttypes & MEDIA_PLAYLIST))
	{
#if !defined(NOMEDIAMENU) && !defined(NOBUILTINMENUS)
		if (!loadedtracknames)
			Media_LoadTrackNames("sound/media.m3u");
#endif
		if (Media_EvaluateNextTrack())
		{
			media_playlistcurrent = MEDIA_PLAYLIST;
			if (*media_currenttrack == '#')
				return S_PrecacheSound2(media_currenttrack+1, true);
			else
				return S_PrecacheSound(media_currenttrack);
		}
	}
	if (!media_playlistcurrent && (media_playlisttypes & MEDIA_CVARLIST))
	{
		if (music_playlist_index.ival >= 0)
		{
			cvar_t *list = Cvar_Get(va("music_playlist_list%i", music_playlist_index.ival), "", 0, "compat");
			if (list)
			{
				cvar_t *sampleposition = Cvar_Get(va("music_playlist_sampleposition%i", music_playlist_index.ival), "-1", 0, "compat");
				Q_snprintfz(media_currenttrack, sizeof(media_currenttrack), "sound/cdtracks/%s", list->string);
				Q_strncpyz(media_friendlyname, "", sizeof(media_friendlyname));
				media_playlistcurrent = MEDIA_CVARLIST;
				music_playlist_last = music_playlist_index.ival;
				if (sampleposition)
				{
					*starttime = sampleposition->value;
					if (*starttime == -1)
						*starttime = 0;
				}
				else
					*starttime = 0;

				s = S_PrecacheSound(media_currenttrack);
			}
		}
	}

	if (!media_playlistcurrent && (media_playlisttypes & MEDIA_GAMEMUSIC))
#endif
	{
#ifdef HAVE_CDPLAYER
		if (cdplaytracknum)
		{
			if (cdplayingtrack != cdplaytracknum && cdpausedtrack != cdplaytracknum)
			{
				CDAudio_Play(cdplaytracknum);
				cdplayingtrack = cdplaytracknum;
			}
#ifdef HAVE_JUKEBOX
			media_playlistcurrent = MEDIA_GAMEMUSIC;
#endif
			return NULL;
		}
#endif
		if (*media_playtrack)
		{
			Q_strncpyz(media_currenttrack, media_playtrack, sizeof(media_currenttrack));
#ifdef HAVE_JUKEBOX
			Q_strncpyz(media_friendlyname, "", sizeof(media_friendlyname));
			media_playlistcurrent = MEDIA_GAMEMUSIC;
#endif
			s = S_PrecacheSound(media_currenttrack);
		}
	}
	return s;
}

//begin cross-fading
static qboolean Media_Changed (unsigned int mediatype)
{
#ifdef HAVE_JUKEBOX
	//something changed, but it has a lower priority so we don't care
	if (mediatype < media_playlistcurrent)
		return false;
#endif

#ifdef HAVE_CDPLAYER
	//make sure we're not playing any cd music.
	if (cdplayingtrack || cdpausedtrack)
	{
		cdplayingtrack = 0;
		cdpausedtrack = 0;
		CDAudio_Stop();
	}
#endif
	media_fadeout = music_fade.ival;
	media_fadeouttime = realtime;
	return true;
}

//returns the new volume the sample should be at, to support crossfading.
//if we return < 0, the mixer will know to kill whatever is currently playing, ready for a new track.
//this is on the main thread with the mixer locked, its safe to do stuff, but try not to block
float Media_CrossFade(int musicchanel, float vol, float time)
{
	if (media_fadeout)
	{
		float fadetime = 1;
		float frac = (fadetime + media_fadeouttime - realtime)/fadetime;
		vol *= frac;
	}
#ifdef HAVE_JUKEBOX
	else if (music_playlist_index.modified)
	{
		if (Media_Changed(MEDIA_CVARLIST))
		{
			if (music_playlist_last >= 0)
			{
				cvar_t *sampleposition = Cvar_Get(va("music_playlist_sampleposition%i", music_playlist_last), "-1", 0, "compat");
				if (sampleposition && sampleposition->value != -1)
					Cvar_SetValue(sampleposition, time);
			}
			vol = -1;	//kill it NOW
		}
	}
#endif
	return vol;
}

void Media_WriteCurrentTrack(sizebuf_t *buf)
{
	//fixme: for demo playback
	MSG_WriteByte (buf, svc_cdtrack);
	MSG_WriteByte (buf, 0);
}

//controls which music track should be playing right now
//track and looptrack will usually be the same thing, track is what to play NOW, looptrack is what to keep re-playing after, or "-" for stop.
qboolean Media_NamedTrack(const char *track, const char *looptrack)
{
	unsigned int tracknum;
	//FIXME: for q2, gog uses ../music/Track%02i.ogg, with various remapping requirements for the mission packs.
	static char *path[] =
	{
		"music/",
		"sound/cdtracks/",
		"",
		NULL
	};
	static char *ext[] =
	{
		"",
#if defined(AVAIL_OGGOPUS) || defined(FTE_TARGET_WEB)
		".opus",	//opus might be the future, but ogg is the present
#endif
#if defined(AVAIL_OGGVORBIS) || defined(FTE_TARGET_WEB)
		".ogg",
#endif
#if defined(AVAIL_MP3_ACM) || defined(FTE_TARGET_WEB)
		".mp3",
#endif
		".wav",
		NULL
	};
	char trackname[MAX_QPATH];
	char tryname[MAX_QPATH];
	int bestdepth = 0x7fffffff, d;
	int ie, ip;
	char *trackend;

	if (!track || !*track)			//ignore calls if the primary track is invalid. whatever is already playing will continue to play.
		return false;
	if (!looptrack || !*looptrack)	//null or empty looptrack loops using the primary track, for compat with q3.
		looptrack = track;

	if (!strcmp(looptrack, "-"))	//- for the looptrack argument can be used to prevent looping.
		looptrack = "";

	//check if its a proper number (0123456789 without any other weird stuff. if so, we can use fake track paths or actual cd tracks)
	tracknum = strtoul(track, &trackend, 10);
	if (*trackend)
		tracknum = 0;	//not a single integer
#ifdef HAVE_CDPLAYER
	if (tracknum > 0 && tracknum < REMAPPED_TRACKS && *cdremap[tracknum].fname)
	{	//remap the track if its remapped.
		track = cdremap[tracknum].fname;
		tracknum = strtoul(track, &trackend, 0);
		if (*trackend)
			tracknum = 0;
	}
#endif

#ifndef HAVE_LEGACY
	if (!tracknum)	//might as well require exact file
	{
		Q_snprintfz(trackname, sizeof(trackname), "%s", track);
		d = COM_FCheckExists(trackname);
	}
	else
#endif
	for(ip = 0; path[ip]; ip++)
	{
		if (tracknum)
		{
			if (*path[ip])
			{
				if (tracknum <= 999)
				{
					for(ie = 0; ext[ie]; ie++)
					{
						Q_snprintfz(tryname, sizeof(tryname), "%strack%03u%s", path[ip], tracknum, ext[ie]);
						d = COM_FDepthFile(tryname, false);
						if (d < bestdepth)
						{
							bestdepth = d;
							Q_strncpy(trackname, tryname, sizeof(trackname));
						}
					}
				}
				if (tracknum <= 99)
				{
					for(ie = 0; ext[ie]; ie++)
					{
						Q_snprintfz(tryname, sizeof(tryname), "%strack%02u%s", path[ip], tracknum, ext[ie]);
						d = COM_FDepthFile(tryname, false);
						if (d < bestdepth)
						{
							bestdepth = d;
							Q_strncpy(trackname, tryname, sizeof(trackname));
						}
					}
				}
			}
		}
		else
		{
			for(ie = 0; ext[ie]; ie++)
			{
				Q_snprintfz(tryname, sizeof(tryname), "%s%s%s", path[ip], track, ext[ie]);
				d = COM_FDepthFile(tryname, false);
				if (d < bestdepth)
				{
					bestdepth = d;
					Q_strncpy(trackname, tryname, sizeof(trackname));
				}
			}
		}
	}

	//okay, do that faketrack thing if we got one.
	if (bestdepth < 0x7fffffff)
	{
#ifdef HAVE_CDPLAYER
		cdplaytracknum = 0;
#endif
		Q_strncpyz(media_playtrack, trackname, sizeof(media_playtrack));
		Q_strncpyz(media_loopingtrack, looptrack, sizeof(media_loopingtrack));
		Media_Changed(MEDIA_GAMEMUSIC);
		return true;
	}

#ifdef HAVE_CDPLAYER
	//couldn't do a faketrack, resort to actual cd tracks, if we're allowed
	if (tracknum && cdenabled)
	{
		Q_strncpyz(media_loopingtrack, looptrack, sizeof(media_loopingtrack));

		if (!CDAudio_Startup())
			return false;
		if (cdnumtracks <= 0)
			cdnumtracks = CDAudio_GetAudioDiskInfo();

		if (tracknum > cdnumtracks)
		{
			Con_DPrintf("CDAudio: Bad track number %u.\n", tracknum);
			return false;	//can't play that, sorry. its not an available track
		}

		if (cdplayingtrack == tracknum)
			return true;	//already playing, don't need to do anything

		cdplaytracknum = tracknum;
		Q_strncpyz(media_playtrack, "", sizeof(media_playtrack));
		Media_Changed(MEDIA_GAMEMUSIC);
		return true;
	}
#endif
	return false;
}

//for q3
void Media_NamedTrack_f(void)
{
	if (Cmd_Argc() == 3)
		Media_NamedTrack(Cmd_Argv(1), Cmd_Argv(2));
	else
		Media_NamedTrack(Cmd_Argv(1), Cmd_Argv(1));
}
void Media_StopTrack_f(void)
{
	*media_playtrack = *media_loopingtrack = 0;
	Media_Changed(MEDIA_GAMEMUSIC);
}

void Media_NumberedTrack(unsigned int initialtrack, unsigned int looptrack)
{
	char *init = initialtrack?va("%u", initialtrack):NULL;
	char *loop = looptrack?va("%u", looptrack):NULL;

	Media_NamedTrack(init, loop);
}

void Media_EndedTrack(void)
{
#ifdef HAVE_CDPLAYER
	cdplayingtrack = 0;
	cdpausedtrack = 0;
#endif

	if (*media_loopingtrack)
		Media_NamedTrack(media_loopingtrack, media_loopingtrack);
}




void Media_SetPauseTrack(qboolean paused)
{
#ifdef HAVE_CDPLAYER
	if (paused)
	{
		if (!cdplayingtrack)
			return;
		cdpausedtrack = cdplayingtrack;
		cdplayingtrack = 0;
		CDAudio_Pause();
	}
	else
	{
		if (!cdpausedtrack)
			return;
		cdplayingtrack = cdpausedtrack;
		cdpausedtrack = 0;
		CDAudio_Resume();
	}
#endif
}

#ifdef HAVE_CDPLAYER
void Media_SaveTracks(vfsfile_t *outcfg)
{
	unsigned int n;
	char buf[MAX_QPATH*4];
	for (n = 1; n < REMAPPED_TRACKS; n++)
		if (*cdremap[n].fname)
			Con_Printf("cd remap %u %s\n", n, COM_QuotedString(cdremap[n].fname, buf, sizeof(buf), false));
}
void CD_f (void)
{
	char	*command;
	int		ret;
	int		n;

	if (Cmd_Argc() < 2)
		return;

	command = Cmd_Argv (1);

	if (Q_strcasecmp(command, "play") == 0)
	{
		Media_NamedTrack(Cmd_Argv(2), "-");
		return;
	}

	if (Q_strcasecmp(command, "loop") == 0)
	{
		if (Cmd_Argc() < 4)
			Media_NamedTrack(Cmd_Argv(2), NULL);
		else
			Media_NamedTrack(Cmd_Argv(2), Cmd_Argv(3));
		return;
	}

	if (Q_strcasecmp(command, "remap") == 0)
	{
		ret = Cmd_Argc() - 2;
		if (ret <= 0)
		{
			for (n = 1; n < REMAPPED_TRACKS; n++)
				if (*cdremap[n].fname)
					Con_Printf("  %u -> %s\n", n, cdremap[n].fname);
			return;
		}
		for (n = 1; n <= ret && n < REMAPPED_TRACKS; n++)
			Q_strncpyz(cdremap[n].fname, Cmd_Argv (n+1), sizeof(cdremap[n].fname));
		return;
	}

	if (Q_strcasecmp(command, "stop") == 0)
	{
		*media_playtrack = *media_loopingtrack = 0;
		cdplaytracknum = 0;
		Media_Changed(MEDIA_GAMEMUSIC);
		return;
	}

	if (!bgmvolume.value)
	{
		Con_Printf("Background music is disabled: %s is 0\n", bgmvolume.name);
		return;
	}

	if (!CDAudio_Startup())
	{
		Con_Printf("No cd drive detected\n");
		return;
	}

	if (Q_strcasecmp(command, "on") == 0)
	{
		cdenabled = true;
		return;
	}

	if (Q_strcasecmp(command, "off") == 0)
	{
		if (cdplayingtrack || cdpausedtrack)
			CDAudio_Stop();
		cdenabled = false;

		*media_playtrack = *media_loopingtrack = 0;
		cdplaytracknum = 0;
		Media_Changed(MEDIA_GAMEMUSIC);
		return;
	}

	if (Q_strcasecmp(command, "reset") == 0)
	{
		cdenabled = true;
		if (cdplayingtrack || cdpausedtrack)
			CDAudio_Stop();
		for (n = 0; n < REMAPPED_TRACKS; n++)
			strcpy(cdremap[n].fname, "");
		cdnumtracks = CDAudio_GetAudioDiskInfo();
		return;
	}

	if (Q_strcasecmp(command, "close") == 0)
	{
		CDAudio_CloseDoor();
		return;
	}

	if (cdnumtracks <= 0)
	{
		cdnumtracks = CDAudio_GetAudioDiskInfo();
		if (cdnumtracks < 0)
		{
			Con_Printf("No CD in player.\n");
			return;
		}
	}

	if (Q_strcasecmp(command, "pause") == 0)
	{
		Media_SetPauseTrack(true);
		return;
	}

	if (Q_strcasecmp(command, "resume") == 0)
	{
		Media_SetPauseTrack(false);
		return;
	}

	if (Q_strcasecmp(command, "eject") == 0)
	{
		if (cdplayingtrack || cdpausedtrack)
			CDAudio_Stop();
		CDAudio_Eject();
		cdnumtracks = -1;
		return;
	}

	if (Q_strcasecmp(command, "info") == 0)
	{
		Con_Printf("%u tracks\n", cdnumtracks);
		if (cdplayingtrack > 0)
			Con_Printf("Currently %s track %u\n", *media_loopingtrack ? "looping" : "playing", cdplayingtrack);
		else if (cdpausedtrack > 0)
			Con_Printf("Paused %s track %u\n", *media_loopingtrack ? "looping" : "playing", cdpausedtrack);
		return;
	}
}
#endif




#ifdef HAVE_JUKEBOX

#ifdef WINAMP

#include "winamp.h"
HWND hwnd_winamp;

#endif

qboolean Media_EvaluateNextTrack(void);


#ifdef WINAMP
qboolean WinAmp_GetHandle (void)
{
	if ((hwnd_winamp = FindWindowW(L"Winamp", NULL)))
		return true;
	if ((hwnd_winamp = FindWindowW(L"Winamp v1.x", NULL)))
		return true;

	*currenttrack.nicename = '\0';

	return false;
}

qboolean WinAmp_StartTune(char *name)
{
	int trys;
	int pos;
	COPYDATASTRUCT cds;
	if (!WinAmp_GetHandle())
		return false;

	//FIXME: extract from fs if it's in a pack.
	//FIXME: always give absolute path
	cds.dwData = IPC_PLAYFILE;
	cds.lpData = (void *) name;
	cds.cbData = strlen((char *) cds.lpData)+1; // include space for null char
	SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_DELETE);
	SendMessage(hwnd_winamp,WM_COPYDATA,(WPARAM)NULL,(LPARAM)&cds);
	SendMessage(hwnd_winamp,WM_WA_IPC,(WPARAM)0,IPC_STARTPLAY );

	for (trys = 1000; trys; trys--)
	{
		pos = SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GETOUTPUTTIME);
		if (pos>100 && SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GETOUTPUTTIME)>=0)	//tune has started
			break;

		Sleep(10);	//give it a chance.
		if (!WinAmp_GetHandle())
			break;
	}

	return true;
}

void WinAmp_Think(void)
{
	int pos;
	int len;

	if (!WinAmp_GetHandle())
		return;

	pos = bgmvolume.value*255;
	if (pos > 255) pos = 255;
	if (pos < 0) pos = 0;
	PostMessage(hwnd_winamp, WM_WA_IPC,pos,IPC_SETVOLUME);

//optimise this to reduce calls?
	pos = SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GETOUTPUTTIME);
	len = SendMessage(hwnd_winamp,WM_WA_IPC,1,IPC_GETOUTPUTTIME)*1000;

	if ((pos > len || pos <= 100) && len != -1)
	if (Media_EvaluateNextTrack())
		WinAmp_StartTune(currenttrack.filename);
}
#endif
void Media_Seek (float time)
{
#ifdef WINAMP
	if (media_hijackwinamp.value)
	{
		int pos;
		if (WinAmp_GetHandle())
		{
			pos = SendMessage(hwnd_winamp,WM_WA_IPC,0,IPC_GETOUTPUTTIME);
			pos += time*1000;
			PostMessage(hwnd_winamp,WM_WA_IPC,pos,IPC_JUMPTOTIME);

			WinAmp_Think();
		}
	}
#endif
	S_Music_Seek(time);
}

void Media_FForward_f(void)
{
	float time = atoi(Cmd_Argv(1));
	if (!time)
		time = 15;
	Media_Seek(time);
}
void Media_Rewind_f (void)
{
	float time = atoi(Cmd_Argv(1));
	if (!time)
		time = 15;
	Media_Seek(-time);
}

qboolean Media_EvaluateNextTrack(void)
{
	mediatrack_t *track;
	int trnum;
	if (!tracks)
		return false;
	if (nexttrack>=0)
	{
		trnum = nexttrack;
		for (track = tracks; track; track=track->next)
		{
			if (!trnum)
			{
				Q_strncpyz(media_currenttrack, track->filename, sizeof(media_currenttrack));
				Q_strncpyz(media_friendlyname, track->nicename, sizeof(media_friendlyname));
				lasttrackplayed = nexttrack;
				break;
			}
			trnum--;
		}
		nexttrack = -1;
	}
	else
	{
		if (media_shuffle.value)
			nexttrack=((float)(rand()&0x7fff)/0x7fff)*numtracks;
		else
		{
			nexttrack = lasttrackplayed+1;
			if (nexttrack >= numtracks)
			{
				if (media_repeat.value)
					nexttrack = 0;
				else
				{
					*media_currenttrack='\0';
					*media_friendlyname='\0';
					return false;
				}
			}
		}
		trnum = nexttrack;
		for (track = tracks; track; track=track->next)
		{
			if (!trnum)
			{
				Q_strncpyz(media_currenttrack, track->filename, sizeof(media_currenttrack));
				Q_strncpyz(media_friendlyname, track->nicename, sizeof(media_friendlyname));
				lasttrackplayed = nexttrack;
				break;
			}
			trnum--;
		}
		nexttrack = -1;
	}

	return true;
}

//actually, this func just flushes and states that it should be playing. the ambientsound func actually changes the track.
void Media_Next_f (void)
{
	Media_Changed(MEDIA_PLAYLIST);

#ifdef WINAMP
	if (media_hijackwinamp.value)
	{
		if (WinAmp_GetHandle())
		if (Media_EvaluateNextTrack())
			WinAmp_StartTune(currenttrack.filename);
	}
#endif
}





void Media_AddTrack(const char *fname)
{
	mediatrack_t *newtrack;
	if (!*fname)
		return;
	for (newtrack = tracks; newtrack; newtrack = newtrack->next)
	{
		if (!strcmp(newtrack->filename, fname))
			return;	//already added. ho hum
	}
	newtrack = Z_Malloc(sizeof(mediatrack_t));
	Q_strncpyz(newtrack->filename, fname, sizeof(newtrack->filename));
	Q_strncpyz(newtrack->nicename, COM_SkipPath(fname), sizeof(newtrack->nicename));
	newtrack->length = 0;
	newtrack->next = tracks;
	tracks = newtrack;
	numtracks++;

	if (numtracks == 1)
		Media_Changed(MEDIA_PLAYLIST);
}
void Media_RemoveTrack(const char *fname)
{
	mediatrack_t **link, *newtrack;
	if (!*fname)
		return;
	for (link = &tracks; *link; link = &(*link)->next)
	{
		newtrack = *link;
		if (!strcmp(newtrack->filename, fname))
		{
			*link = newtrack->next;
			numtracks--;

			if (!strcmp(media_currenttrack, newtrack->filename))
				Media_Changed(MEDIA_PLAYLIST);
			Z_Free(newtrack);
			return;
		}
	}
}
void M_Media_Add_f (void)
{
	char *fname = Cmd_Argv(1);

	if (!loadedtracknames)
		Media_LoadTrackNames("sound/media.m3u");

	if (Cmd_Argc() == 1)
		Con_Printf("%s <track>\n", Cmd_Argv(0));
	else
		Media_AddTrack(fname);

	Media_SaveTrackNames("sound/media.m3u");
}
void M_Media_Remove_f (void)
{
	char *fname = Cmd_Argv(1);

	if (Cmd_Argc() == 1)
		Con_Printf("%s <track>\n", Cmd_Argv(0));
	else
		Media_RemoveTrack(fname);

	Media_SaveTrackNames("sound/media.m3u");
}


#if !defined(NOMEDIAMENU) && !defined(NOBUILTINMENUS)

void Media_LoadTrackNames (char *listname);

#define MEDIA_MIN	-7
#define MEDIA_VOLUME -7
#define MEDIA_FASTFORWARD -6
#define MEDIA_CLEARLIST -5
#define MEDIA_ADDTRACK -4
#define MEDIA_ADDLIST -3
#define MEDIA_SHUFFLE -2
#define MEDIA_REPEAT -1

void M_Media_Draw (menu_t *menu)
{
	mediatrack_t *track;
	int y;
	int op, i, mop;
	qboolean playing;

	float time, duration;
	char title[256];
	playing = S_GetMusicInfo(0, &time, &duration, title, sizeof(title));

#define MP_Hightlight(x,y,text,hl) (hl?M_PrintWhite(x, y, text):M_Print(x, y, text))

	if (!bgmvolume.value)
		M_Print (12, 32, "Not playing - no volume");
	else if (!*media_currenttrack)
	{
		if (!tracks)
			M_Print (12, 32, "Not playing - no track to play");
		else
		{
#ifdef WINAMP
			if (!WinAmp_GetHandle())
				M_Print (12, 32, "Please start WinAmp 2");
			else
#endif
				M_Print (12, 32, "Not playing - switched off");
		}
	}
	else
	{
		M_Print (12, 32, "Currently playing:");
		if (*title)
		{
			M_Print (12, 40, title);
			M_Print (12, 48, media_currenttrack);
		}
		else
			M_Print (12, 40, *media_friendlyname?media_friendlyname:media_currenttrack);
	}

	y=60;
	op = selectedoption - (vid.height-y)/16;
	if (op + (vid.height-y)/8>numtracks)
		op = numtracks - (vid.height-y)/8;
	if (op < MEDIA_MIN)
		op = MEDIA_MIN;
	mop = (mousecursor_y - y)/8;
	mop += MEDIA_MIN;
	mouseselectedoption = MEDIA_MIN-1;
	if (mousecursor_x < 12 + ((vid.width - 320)>>1) || mousecursor_x > 320-24 + ((vid.width - 320)>>1))
		mop = mouseselectedoption;
	while(op < 0)
	{
		if (op == mop)
		{
			float alphamax = 0.5, alphamin = 0.2;
			mouseselectedoption = op;
			R2D_ImageColours(.5,.4,0,(sin(realtime*2)+1)*0.5*(alphamax-alphamin)+alphamin);
			R2D_FillBlock(12 + ((vid.width - 320)>>1), y, 320-24, 8);
			R2D_ImageColours(1.0, 1.0, 1.0, 1.0);
		}
		switch(op)
		{
		case MEDIA_VOLUME:
			MP_Hightlight (12, y, va("<< Volume %2i%%    >>", (int)(100*bgmvolume.value)), op == selectedoption);
			y+=8;
			break;
		case MEDIA_CLEARLIST:
			MP_Hightlight (12, y, "Clear all", op == selectedoption);
			y+=8;
			break;
		case MEDIA_FASTFORWARD:
			{
				if (playing)
				{
					int itime = time;
					int iduration = duration;
					if (iduration)
					{
						int pct = (int)((100*time)/duration);
						MP_Hightlight (12, y, va("<< %i:%02i / %i:%02i - %i%% >>", itime/60, itime%60, iduration/60, iduration%60, pct), op == selectedoption);
					}
					else
						MP_Hightlight (12, y, va("<< %i:%02i >>", itime/60, itime%60), op == selectedoption);
				}
				else
					MP_Hightlight (12, y, "<<    skip		 >>", op == selectedoption);
			}
			y+=8;
			break;
		case MEDIA_ADDTRACK:
			MP_Hightlight (12, y, "Add Track", op == selectedoption);
			if (op == selectedoption)
				M_PrintWhite (12+9*8, y, media_iofilename);
			y+=8;
			break;
		case MEDIA_ADDLIST:
			MP_Hightlight (12, y, "Add List", op == selectedoption);
			if (op == selectedoption)
				M_PrintWhite (12+9*8, y, media_iofilename);
			y+=8;
			break;
		case MEDIA_SHUFFLE:
			if (media_shuffle.value)
				MP_Hightlight (12, y, "Shuffle on", op == selectedoption);
			else
				MP_Hightlight (12, y, "Shuffle off", op == selectedoption);
			y+=8;
			break;
		case MEDIA_REPEAT:
			if (!media_shuffle.value)
			{
				if (media_repeat.value)
					MP_Hightlight (12, y, "Repeat on", op == selectedoption);
				else
					MP_Hightlight (12, y, "Repeat off", op == selectedoption);
			}
			else
			{
				if (media_repeat.value)
					MP_Hightlight (12, y, "(Repeat on)", op == selectedoption);
				else
					MP_Hightlight (12, y, "(Repeat off)", op == selectedoption);
			}
			y+=8;
			break;
		}
		op++;
	}

	for (track = tracks, i=0; track && i<op; track=track->next, i++);
	for (; track; track=track->next, y+=8, op++)
	{
		if (track->length != (int)duration && *title && !strcmp(track->filename, media_currenttrack))
		{
			Q_strncpyz(track->nicename, title, sizeof(track->nicename));
			track->length = duration;
			Media_SaveTrackNames("sound/media.m3u");
		}

		if (op == mop)
		{
			float alphamax = 0.5, alphamin = 0.2;
			mouseselectedoption = op;
			R2D_ImageColours(.5,.4,0,(sin(realtime*2)+1)*0.5*(alphamax-alphamin)+alphamin);
			R2D_FillBlock(12 + ((vid.width - 320)>>1), y, 320-24, 8);
			R2D_ImageColours(1.0, 1.0, 1.0, 1.0);
		}
		if (op == selectedoption)
			M_PrintWhite (12, y, track->nicename);
		else
			M_Print (12, y, track->nicename);
	}
}

char compleatenamepath[MAX_OSPATH];
char compleatenamename[MAX_OSPATH];
qboolean compleatenamemultiple;
int QDECL Com_CompleatenameCallback(const char *name, qofs_t size, time_t mtime, void *data, searchpathfuncs_t *spath)
{
	if (*compleatenamename)
		compleatenamemultiple = true;
	Q_strncpyz(compleatenamename, name, sizeof(compleatenamename));

	return true;
}
void Com_CompleateOSFileName(char *name)
{
	char *ending;
	compleatenamemultiple = false;

	strcpy(compleatenamepath, name);
	ending = COM_SkipPath(compleatenamepath);
	if (compleatenamepath!=ending)
		ending[-1] = '\0';	//strip a slash
	*compleatenamename='\0';

	Sys_EnumerateFiles(NULL, va("%s*", name), Com_CompleatenameCallback, NULL, NULL);
	Sys_EnumerateFiles(NULL, va("%s*.*", name), Com_CompleatenameCallback, NULL, NULL);

	if (*compleatenamename)
		strcpy(name, compleatenamename);
}

qboolean M_Media_Key (int key, menu_t *menu)
{
	int dir;
	if (key == K_ESCAPE || key == K_GP_BACK || key == K_MOUSE2)
	{
		return false;
	}
	else if (key == K_RIGHTARROW || key == K_KP_RIGHTARROW || key == K_GP_DPAD_RIGHT || key == K_LEFTARROW || key == K_KP_LEFTARROW || key == K_GP_DPAD_LEFT)
	{
		if (key == K_RIGHTARROW || key == K_KP_RIGHTARROW || key == K_GP_DPAD_RIGHT)
			dir = 1;
		else dir = -1;
		switch(selectedoption)
		{
		case MEDIA_VOLUME:
			bgmvolume.value += dir * 0.1;
			if (bgmvolume.value < 0)
				bgmvolume.value = 0;
			if (bgmvolume.value > 1)
				bgmvolume.value = 1;
			Cvar_SetValue (&bgmvolume, bgmvolume.value);
			break;
		case MEDIA_FASTFORWARD:
			Media_Seek(15*dir);
			break;
		default:
			if (selectedoption >= 0)
				Media_Next_f();
			break;
		}
	}
	else if (key == K_DOWNARROW || key == K_KP_DOWNARROW || key == K_GP_DPAD_DOWN)
	{
		selectedoption++;
		if (selectedoption>=numtracks)
			selectedoption = numtracks-1;
	}
	else if (key == K_PGDN)
	{
		selectedoption+=10;
		if (selectedoption>=numtracks)
			selectedoption = numtracks-1;
	}
	else if (key == K_UPARROW || key == K_KP_UPARROW || key == K_GP_DPAD_UP)
	{
		selectedoption--;
		if (selectedoption < MEDIA_MIN)
			selectedoption = MEDIA_MIN;
	}
	else if (key == K_PGUP)
	{
		selectedoption-=10;
		if (selectedoption < MEDIA_MIN)
			selectedoption = MEDIA_MIN;
	}
	else if (key == K_DEL)
	{
		if (selectedoption>=0)
		{
			mediatrack_t *prevtrack=NULL, *tr;
			int num=0;
			tr=tracks;
			while(tr)
			{
				if (num == selectedoption)
				{
					if (prevtrack)
						prevtrack->next = tr->next;
					else
						tracks = tr->next;
					numtracks--;
					if (!strcmp(media_currenttrack, tr->filename))
						Media_Changed(MEDIA_PLAYLIST);
					Z_Free(tr);
					break;
				}

				prevtrack = tr;
				tr=tr->next;
				num++;
			}
		}
	}
	else if (key == K_ENTER || key == K_KP_ENTER || key == K_GP_START || key == K_MOUSE1)
	{
		if (key == K_MOUSE1)
		{
			if (mouseselectedoption < MEDIA_MIN)
				return false;
			selectedoption = mouseselectedoption;
		}
		switch(selectedoption)
		{
		case MEDIA_FASTFORWARD:
			Media_Seek(15);
			break;
		case MEDIA_CLEARLIST:
			{
				mediatrack_t *prevtrack;
				while(tracks)
				{
					prevtrack = tracks;
					tracks=tracks->next;
					Z_Free(prevtrack);
					numtracks--;
				}
				if (numtracks!=0)
				{
					numtracks=0;
					Con_SafePrintf("numtracks should be 0\n");
				}
				Media_Changed(MEDIA_PLAYLIST);
			}
			break;
		case MEDIA_ADDTRACK:
			if (*media_iofilename)
				Media_AddTrack(media_iofilename);
			else
				Cmd_ExecuteString("menu_mediafiles", RESTRICT_LOCAL);
			break;
		case MEDIA_ADDLIST:
			if (*media_iofilename)
				Media_LoadTrackNames(media_iofilename);
			break;
		case MEDIA_SHUFFLE:
			Cvar_Set(&media_shuffle, media_shuffle.value?"0":"1");
			break;
		case MEDIA_REPEAT:
			Cvar_Set(&media_repeat, media_repeat.value?"0":"1");
			break;
		default:
			if (selectedoption>=0)
			{
				nexttrack = selectedoption;
				Media_Next_f();
				return true;
			}
			return false;
		}
		return true;
	}
	else
	{
		if (selectedoption == MEDIA_ADDLIST || selectedoption == MEDIA_ADDTRACK)
		{
			if (key == K_TAB)
			{
				Com_CompleateOSFileName(media_iofilename);
				return true;
			}
			else if (key == K_BACKSPACE)
			{
				dir = strlen(media_iofilename);
				if (dir)
					media_iofilename[dir-1] = '\0';
				return true;
			}
			else if ((key >= 'a' && key <= 'z') || (key >= '0' && key <= '9') || key == '/' || key == '_' || key == '.' || key == ':')
			{
				dir = strlen(media_iofilename);
				media_iofilename[dir] = key;
				media_iofilename[dir+1] = '\0';
				return true;
			}
		}
		else if (selectedoption>=0)
		{
			mediatrack_t *tr;
			int num=0;
			tr=tracks;
			while(tr)
			{
				if (num == selectedoption)
					break;

				tr=tr->next;
				num++;
			}
			if (!tr)
				return false;

			if (key == K_BACKSPACE)
			{
				dir = strlen(tr->nicename);
				if (dir)
					tr->nicename[dir-1] = '\0';
				return true;
			}
			else if ((key >= 'a' && key <= 'z') || (key >= '0' && key <= '9') || key == '/' || key == '_' || key == '.' || key == ':'  || key == '&' || key == '|' || key == '#' || key == '\'' || key == '\"' || key == '\\' || key == '*' || key == '@' || key == '!' || key == '(' || key == ')' || key == '%' || key == '^' || key == '?' || key == '[' || key == ']' || key == ';' || key == ':' || key == '+' || key == '-' || key == '=')
			{
				dir = strlen(tr->nicename);
				tr->nicename[dir] = key;
				tr->nicename[dir+1] = '\0';
				return true;
			}
		}
	}
	return false;
}

void M_Menu_Media_f (void)
{
	menu_t *menu;
	if (!loadedtracknames)
		Media_LoadTrackNames("sound/media.m3u");

	Key_Dest_Add(kdm_emenu);
	menu = M_CreateMenu(0);

//	MC_AddPicture(menu, 16, 4, 32, 144, "gfx/qplaque.lmp");
	MC_AddCenterPicture(menu, 4, 24, "gfx/p_option.lmp");

	menu->key = M_Media_Key;
	menu->postdraw = M_Media_Draw;
}



void Media_SaveTrackNames (char *listname)
{
	mediatrack_t *tr;
	vfsfile_t *f = FS_OpenVFS(listname, "wb", FS_GAMEONLY);
	if (!f)
		return;
	VFS_PRINTF(f, "#EXTM3U\n");
	for (tr = tracks; tr; tr = tr->next)
	{
		VFS_PRINTF(f, "#EXTINF:%i,%s\n%s\n", tr->length, tr->nicename, tr->filename);
	}
	VFS_CLOSE(f);
}

//safeprints only.
void Media_LoadTrackNames (char *listname)
{
	char *lineend;
	char *len;
	char *filename;
	char *trackname;
	mediatrack_t *newtrack;
	size_t fsize;
	char *data = COM_LoadTempFile(listname, FSLF_IGNOREPURE, &fsize);

	loadedtracknames=true;

	if (!data)
		return;

	if (!Q_strncasecmp(data, "#extm3u", 7))
	{
		data = strchr(data, '\n')+1;
		for(;;)
		{
			lineend = strchr(data, '\n');

			if (Q_strncasecmp(data, "#extinf:", 8))
			{
				if (!lineend)
					return;
				Con_SafePrintf("Bad m3u file\n");
				return;
			}
			len = data+8;
			trackname = strchr(data, ',')+1;
			if (!trackname)
				return;

			if (lineend > data && lineend[-1] == '\r')
				lineend[-1]='\0';
			else
				lineend[0]='\0';

			filename = data = lineend+1;

			lineend = strchr(data, '\n');

			if (lineend)
			{
				if (lineend > data && lineend[-1] == '\r')
					lineend[-1]='\0';
				else
					lineend[0]='\0';
				data = lineend+1;
			}

			newtrack = Z_Malloc(sizeof(mediatrack_t));
			Q_strncpyz(newtrack->filename, filename, sizeof(newtrack->filename));
			Q_strncpyz(newtrack->nicename, trackname, sizeof(newtrack->nicename));
			newtrack->length = atoi(len);
			newtrack->next = tracks;
			tracks = newtrack;
			numtracks++;

			if (!lineend)
				return;
		}
	}
	else
	{
		for(;;)
		{
			trackname = filename = data;
			lineend = strchr(data, '\n');

			if (!lineend && !*data)
				break;
			lineend[-1]='\0';
			data = lineend+1;

			newtrack = Z_Malloc(sizeof(mediatrack_t));
			Q_strncpyz(newtrack->filename, filename, sizeof(newtrack->filename));
			Q_strncpyz(newtrack->nicename, COM_SkipPath(trackname), sizeof(newtrack->nicename));
			newtrack->length = 0;
			newtrack->next = tracks;
			tracks = newtrack;
			numtracks++;

			if (!lineend)
				break;
		}
	}
}
#endif

#endif





///temporary residence for media handling

#ifdef HAVE_API_VFW
#if 0
#include <vfw.h>
#else
typedef struct 
{
	DWORD fccType;
	DWORD fccHandler;
	DWORD dwFlags;
	DWORD dwCaps;
	WORD  wPriority;
	WORD  wLanguage;
	DWORD dwScale;
	DWORD dwRate;
	DWORD dwStart;
	DWORD dwLength;
	DWORD dwInitialFrames;
	DWORD dwSuggestedBufferSize;
	DWORD dwQuality;
	DWORD dwSampleSize;
	RECT  rcFrame;
	DWORD dwEditCount;
	DWORD dwFormatChangeCount;
	TCHAR szName[64];
} AVISTREAMINFOA, *LPAVISTREAMINFOA;
typedef struct AVISTREAM *PAVISTREAM;
typedef struct AVIFILE *PAVIFILE;
typedef struct GETFRAME *PGETFRAME;
typedef struct	 
{
	DWORD  fccType;
	DWORD  fccHandler;
	DWORD  dwKeyFrameEvery;
	DWORD  dwQuality;
	DWORD  dwBytesPerSecond;
	DWORD  dwFlags;
	LPVOID lpFormat;
	DWORD  cbFormat;
	LPVOID lpParms;
	DWORD  cbParms;
	DWORD  dwInterleaveEvery;
} AVICOMPRESSOPTIONS;
#define streamtypeVIDEO         mmioFOURCC('v', 'i', 'd', 's')
#define streamtypeAUDIO         mmioFOURCC('a', 'u', 'd', 's')
#define AVISTREAMREAD_CONVENIENT	(-1L)
#define AVIIF_KEYFRAME	0x00000010L
#endif

ULONG	(WINAPI *qAVIStreamRelease)			(PAVISTREAM pavi);
HRESULT	(WINAPI *qAVIStreamEndStreaming)	(PAVISTREAM pavi);
HRESULT	(WINAPI *qAVIStreamGetFrameClose)	(PGETFRAME pg);
HRESULT	(WINAPI *qAVIStreamRead)			(PAVISTREAM pavi, LONG lStart, LONG lSamples, LPVOID lpBuffer, LONG cbBuffer, LONG FAR * plBytes, LONG FAR * plSamples);
LPVOID	(WINAPI *qAVIStreamGetFrame)		(PGETFRAME pg, LONG lPos);
HRESULT	(WINAPI *qAVIStreamReadFormat)		(PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG FAR *lpcbFormat);
LONG	(WINAPI *qAVIStreamStart)			(PAVISTREAM pavi);
PGETFRAME(WINAPI*qAVIStreamGetFrameOpen)	(PAVISTREAM pavi, LPBITMAPINFOHEADER lpbiWanted);
HRESULT	(WINAPI *qAVIStreamBeginStreaming)	(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate);
LONG	(WINAPI *qAVIStreamSampleToTime)	(PAVISTREAM pavi, LONG lSample);
LONG	(WINAPI *qAVIStreamLength)			(PAVISTREAM pavi);
HRESULT	(WINAPI *qAVIStreamInfoA)			(PAVISTREAM pavi, LPAVISTREAMINFOA psi, LONG lSize);
ULONG	(WINAPI *qAVIFileRelease)			(PAVIFILE pfile);
HRESULT	(WINAPI *qAVIFileGetStream)			(PAVIFILE pfile, PAVISTREAM FAR * ppavi, DWORD fccType, LONG lParam);
HRESULT	(WINAPI *qAVIFileOpenA)				(PAVIFILE FAR *ppfile, LPCSTR szFile, UINT uMode, LPCLSID lpHandler);
void	(WINAPI *qAVIFileInit)				(void);
HRESULT	(WINAPI *qAVIStreamWrite)			(PAVISTREAM pavi, LONG lStart, LONG lSamples, LPVOID lpBuffer, LONG cbBuffer, DWORD dwFlags, LONG FAR *plSampWritten, LONG FAR *plBytesWritten);
HRESULT	(WINAPI *qAVIStreamSetFormat)		(PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG cbFormat);
HRESULT	(WINAPI *qAVIMakeCompressedStream)	(PAVISTREAM FAR * ppsCompressed, PAVISTREAM ppsSource, AVICOMPRESSOPTIONS FAR * lpOptions, CLSID FAR *pclsidHandler);
HRESULT	(WINAPI *qAVIFileCreateStreamA)		(PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFOA FAR * psi);

static qboolean qAVIStartup(void)
{
	static int aviinited;
	static dllhandle_t *avimodule;
	if (!aviinited)
	{
		dllfunction_t funcs[] =
		{
			{(void*)&qAVIFileInit,				"AVIFileInit"},
			{(void*)&qAVIStreamRelease,			"AVIStreamRelease"},
			{(void*)&qAVIStreamEndStreaming,	"AVIStreamEndStreaming"},
			{(void*)&qAVIStreamGetFrameClose,	"AVIStreamGetFrameClose"},
			{(void*)&qAVIStreamRead,			"AVIStreamRead"},
			{(void*)&qAVIStreamGetFrame,		"AVIStreamGetFrame"},
			{(void*)&qAVIStreamReadFormat,		"AVIStreamReadFormat"},
			{(void*)&qAVIStreamStart,			"AVIStreamStart"},
			{(void*)&qAVIStreamGetFrameOpen,	"AVIStreamGetFrameOpen"},
			{(void*)&qAVIStreamBeginStreaming,	"AVIStreamBeginStreaming"},
			{(void*)&qAVIStreamSampleToTime,	"AVIStreamSampleToTime"},
			{(void*)&qAVIStreamLength,			"AVIStreamLength"},
			{(void*)&qAVIStreamInfoA,			"AVIStreamInfoA"},
			{(void*)&qAVIFileRelease,			"AVIFileRelease"},
			{(void*)&qAVIFileGetStream,			"AVIFileGetStream"},
			{(void*)&qAVIFileOpenA,				"AVIFileOpenA"},
			{(void*)&qAVIStreamWrite,			"AVIStreamWrite"},
			{(void*)&qAVIStreamSetFormat,		"AVIStreamSetFormat"},
			{(void*)&qAVIMakeCompressedStream,	"AVIMakeCompressedStream"},
			{(void*)&qAVIFileCreateStreamA,		"AVIFileCreateStreamA"},
			{NULL,NULL}
		};
		aviinited = true;
		avimodule = Sys_LoadLibrary("avifil32.dll", funcs);

		if (avimodule)
			qAVIFileInit();
	}

	return avimodule?true:false;
}
#endif

#ifdef HAVE_MEDIA_DECODER

static char *cin_prop_buf;
static size_t cin_prop_bufsize;
struct cin_s
{
	qboolean (*decodeframe)(cin_t *cin, qboolean nosound, qboolean forcevideo, double mediatime, void (QDECL *uploadtexture)(void *ctx, uploadfmt_t fmt, int width, int height, void *data, void *palette), void *ctx);
	void (*shutdown)(cin_t *cin);	//warning: doesn't free cin_t
	void (*rewind)(cin_t *cin);
	//these are any interactivity functions you might want...
	void (*cursormove) (struct cin_s *cin, float posx, float posy);	//pos is 0-1
	void (*key) (struct cin_s *cin, int code, int unicode, int event);
	qboolean (*setsize) (struct cin_s *cin, int width, int height);
	void (*getsize) (struct cin_s *cin, int *width, int *height, float *aspect);
	void (*changestream) (struct cin_s *cin, const char *streamname);
	qboolean (*getproperty) (struct cin_s *cin, const char *key, char *buffer, size_t *buffersize);



	//these are the outputs (not always power of two!)
	cinstates_t playstate;
	qboolean forceframe;
	float filmpercentage;

	texid_t texture;


#ifdef HAVE_API_VFW
	struct {
		AVISTREAMINFOA		vidinfo;
		PAVISTREAM			pavivideo;
		AVISTREAMINFOA		audinfo;
		PAVISTREAM			pavisound;
		PAVIFILE			pavi;
		PGETFRAME			pgf;

		HACMSTREAM			audiodecoder;

		LPWAVEFORMATEX pWaveFormat;

		//sound stuff
		int soundpos;
		int currentframe;	//previously displayed frame, to avoid excess decoding

		//source info
		float filmfps;
		int num_frames;
	} avi;
#endif

#ifdef PLUGINS
	struct {
		void *ctx;
		struct plugin_s *plug;
		media_decoder_funcs_t *funcs;	/*fixme*/
		struct cin_s *next;
		struct cin_s *prev;
	} plugin;
#endif

	struct {
		qbyte *filmimage;	//rgba
		int imagewidth;
		int imageheight;
	} image;

	struct {
		struct roq_info_s *roqfilm;
//		float lastmediatime;
		float nextframetime;
	} roq;

	struct {
		struct cinematics_s *cin;
	} q2cin;

	float filmstarttime;

	qbyte *framedata;	//Z_Malloced buffer
};

shader_t *videoshader;

//////////////////////////////////////////////////////////////////////////////////
//AVI Support (windows)
#ifdef HAVE_API_VFW
static void Media_WinAvi_Shutdown(struct cin_s *cin)
{
	qAVIStreamGetFrameClose(cin->avi.pgf);
	qAVIStreamEndStreaming(cin->avi.pavivideo);
	qAVIStreamRelease(cin->avi.pavivideo);
	//we don't need to free the file (we freed it immediatly after getting the stream handles)
}
static void Media_WinAvi_Rewind (cin_t *cin)
{
	cin->avi.soundpos = 0;
	cin->avi.currentframe = -1;
}
static qboolean Media_WinAvi_DecodeFrame (cin_t *cin, qboolean nosound, qboolean forcevideo, double mediatime, void (QDECL *uploadtexture)(void *ctx, uploadfmt_t fmt, int width, int height, void *data, void *palette), void *ctx)
{
	LPBITMAPINFOHEADER lpbi;									// Holds The Bitmap Header Information
	float newframe;
	int newframei;
	int wantsoundtime;
	extern cvar_t _snd_mixahead;


	newframe = ((mediatime * cin->avi.vidinfo.dwRate) / cin->avi.vidinfo.dwScale) + cin->avi.vidinfo.dwInitialFrames;
	newframei = newframe;

	if (newframei>=cin->avi.num_frames)
		return false;

	if (newframei == cin->avi.currentframe && !forcevideo)
		return true;

	if (cin->avi.currentframe < newframei-1)
		Con_DPrintf("Dropped %i frame(s)\n", (newframei - cin->avi.currentframe)-1);

	cin->avi.currentframe = newframei;
	cin->filmpercentage = newframe / cin->avi.num_frames;

	if (newframei>=cin->avi.num_frames)
		return false;
	
	lpbi = (LPBITMAPINFOHEADER)qAVIStreamGetFrame(cin->avi.pgf, newframei);	// Grab Data From The AVI Stream
	if (!lpbi || lpbi->biBitCount != 24)//oops
		return false;

	uploadtexture(ctx, TF_BGR24_FLIP, lpbi->biWidth, lpbi->biHeight, (char*)lpbi+lpbi->biSize, NULL);

	if(nosound)
		wantsoundtime = 0;
	else
		wantsoundtime = (((mediatime + _snd_mixahead.value + 0.02) * cin->avi.audinfo.dwRate) / cin->avi.audinfo.dwScale) + cin->avi.audinfo.dwInitialFrames;

	while (cin->avi.pavisound && cin->avi.soundpos < wantsoundtime)
	{
		LONG lSize;
		LPBYTE pBuffer;
		LONG samples;

		/*if the audio skipped more than a second, drop it all and start at a sane time, so our raw audio playing code doesn't buffer too much*/
		if (cin->avi.soundpos + (1*cin->avi.audinfo.dwRate / cin->avi.audinfo.dwScale) < wantsoundtime)
		{
			cin->avi.soundpos = wantsoundtime;
			break;
		}

		qAVIStreamRead(cin->avi.pavisound, cin->avi.soundpos, AVISTREAMREAD_CONVENIENT, NULL, 0, &lSize, &samples);
		pBuffer = cin->framedata;
		qAVIStreamRead(cin->avi.pavisound, cin->avi.soundpos, AVISTREAMREAD_CONVENIENT, pBuffer, lSize, NULL, &samples);

		cin->avi.soundpos+=samples;

		/*if no progress, stop!*/
		if (!samples)
			break;

		if (cin->avi.audiodecoder)
		{
			ACMSTREAMHEADER strhdr;
			char buffer[1024*256];

			memset(&strhdr, 0, sizeof(strhdr));
			strhdr.cbStruct = sizeof(strhdr);
			strhdr.pbSrc = pBuffer;
			strhdr.cbSrcLength = lSize;
			strhdr.pbDst = buffer;
			strhdr.cbDstLength = sizeof(buffer);

			qacmStreamPrepareHeader(cin->avi.audiodecoder, &strhdr, 0);
			qacmStreamConvert(cin->avi.audiodecoder, &strhdr, ACM_STREAMCONVERTF_BLOCKALIGN);
			qacmStreamUnprepareHeader(cin->avi.audiodecoder, &strhdr, 0);

			S_RawAudio(-1, strhdr.pbDst, cin->avi.pWaveFormat->nSamplesPerSec, strhdr.cbDstLengthUsed/4, cin->avi.pWaveFormat->nChannels, 2, volume.value);
		}
		else
			S_RawAudio(-1, pBuffer, cin->avi.pWaveFormat->nSamplesPerSec, samples, cin->avi.pWaveFormat->nChannels, 2, volume.value);
	}
	return true;
}

static cin_t *Media_WinAvi_TryLoad(char *name)
{
	cin_t *cin;
	PAVIFILE			pavi;
	flocation_t loc;

	if (strchr(name, ':'))
		return NULL;

	if (!qAVIStartup())
		return NULL;


	FS_FLocateFile(name, FSLF_IFFOUND, &loc);

	if (!loc.offset && *loc.rawname && !qAVIFileOpenA(&pavi, loc.rawname, OF_READ, NULL))//!AVIStreamOpenFromFile(&pavi, name, streamtypeVIDEO, 0, OF_READ, NULL))
	{
		int filmwidth;
		int filmheight;

		cin = Z_Malloc(sizeof(cin_t));
		cin->avi.pavi = pavi;

		if (qAVIFileGetStream(cin->avi.pavi, &cin->avi.pavivideo, streamtypeVIDEO, 0))	//retrieve video stream
		{
			qAVIFileRelease(pavi);
			Con_Printf("%s contains no video stream\n", name);
			return NULL;
		}
		if (qAVIFileGetStream(cin->avi.pavi, &cin->avi.pavisound, streamtypeAUDIO, 0))	//retrieve audio stream
		{
			Con_DPrintf("%s contains no audio stream\n", name);
			cin->avi.pavisound=NULL;
		}
		qAVIFileRelease(cin->avi.pavi);

//play with video
		qAVIStreamInfoA(cin->avi.pavivideo, &cin->avi.vidinfo, sizeof(cin->avi.vidinfo));
		filmwidth=cin->avi.vidinfo.rcFrame.right-cin->avi.vidinfo.rcFrame.left;					// Width Is Right Side Of Frame Minus Left
		filmheight=cin->avi.vidinfo.rcFrame.bottom-cin->avi.vidinfo.rcFrame.top;					// Height Is Bottom Of Frame Minus Top
		cin->framedata = BZ_Malloc(filmwidth*filmheight*4);

		cin->avi.num_frames=qAVIStreamLength(cin->avi.pavivideo);							// The Last Frame Of The Stream
		cin->avi.filmfps=1000.0f*(float)cin->avi.num_frames/(float)qAVIStreamSampleToTime(cin->avi.pavivideo,cin->avi.num_frames);		// Calculate Rough Milliseconds Per Frame

		qAVIStreamBeginStreaming(cin->avi.pavivideo, 0, cin->avi.num_frames, 100);

		cin->avi.pgf=qAVIStreamGetFrameOpen(cin->avi.pavivideo, NULL);

		if (!cin->avi.pgf)
		{
			Con_Printf("AVIStreamGetFrameOpen failed. Please install a vfw codec for '%c%c%c%c'. Try ffdshow.\n", 
				((unsigned char*)&cin->avi.vidinfo.fccHandler)[0],
				((unsigned char*)&cin->avi.vidinfo.fccHandler)[1],
				((unsigned char*)&cin->avi.vidinfo.fccHandler)[2],
				((unsigned char*)&cin->avi.vidinfo.fccHandler)[3]
				);
		}

		cin->avi.currentframe=-1;
		cin->filmstarttime = Sys_DoubleTime();

		cin->avi.soundpos=0;


//play with sound
		if (cin->avi.pavisound)
		{
			LONG lSize;
			LPBYTE pChunk;
			qAVIStreamInfoA(cin->avi.pavisound, &cin->avi.audinfo, sizeof(cin->avi.audinfo));

			qAVIStreamRead(cin->avi.pavisound, 0, AVISTREAMREAD_CONVENIENT, NULL, 0, &lSize, NULL);

			if (!lSize)
				cin->avi.pWaveFormat = NULL;
			else
			{
				pChunk = BZ_Malloc(sizeof(qbyte)*lSize);

				if(qAVIStreamReadFormat(cin->avi.pavisound, qAVIStreamStart(cin->avi.pavisound), pChunk, &lSize))
				{
				   // error
					Con_Printf("Failiure reading sound info\n");
				}
				cin->avi.pWaveFormat = (LPWAVEFORMATEX)pChunk;
			}

			if (!cin->avi.pWaveFormat)
			{
				Con_Printf("VFW: unable to decode audio\n");
				qAVIStreamRelease(cin->avi.pavisound);
				cin->avi.pavisound=NULL;
			}
			else if (cin->avi.pWaveFormat->wFormatTag != 1)
			{
				WAVEFORMATEX pcm_format;
				HACMDRIVER drv = NULL;

				memset (&pcm_format, 0, sizeof(pcm_format));
				pcm_format.wFormatTag = WAVE_FORMAT_PCM;
				pcm_format.nChannels = cin->avi.pWaveFormat->nChannels;
				pcm_format.nSamplesPerSec = cin->avi.pWaveFormat->nSamplesPerSec;
				pcm_format.nBlockAlign = 4;
				pcm_format.nAvgBytesPerSec = pcm_format.nSamplesPerSec*4;
				pcm_format.wBitsPerSample = 16;
				pcm_format.cbSize = 0;

				if (!qacmStartup() || 0!=qacmStreamOpen(&cin->avi.audiodecoder, drv, cin->avi.pWaveFormat, &pcm_format, NULL, 0, 0, 0))
				{
					Con_Printf("Failed to open audio decoder\n");	//FIXME: so that it no longer is...
					qAVIStreamRelease(cin->avi.pavisound);
					cin->avi.pavisound=NULL;
				}
			}
		}

		cin->decodeframe = Media_WinAvi_DecodeFrame;
		cin->rewind = Media_WinAvi_Rewind;
		cin->shutdown = Media_WinAvi_Shutdown;
		return cin;
	}
	return NULL;
}
#endif

//AVI Support (windows)
//////////////////////////////////////////////////////////////////////////////////
//Plugin Support
#ifdef PLUGINS
static media_decoder_funcs_t *plugindecodersfunc[8];
static struct plugin_s *plugindecodersplugin[8];
static cin_t *active_cin_plugins;

qboolean Media_RegisterDecoder(struct plugin_s *plug, media_decoder_funcs_t *funcs)
{
	int i;
	if (!funcs || funcs->structsize != sizeof(*funcs))
		return false;

	for (i = 0; i < sizeof(plugindecodersfunc)/sizeof(plugindecodersfunc[0]); i++)
	{
		if (plugindecodersfunc[i] == NULL)
		{
			plugindecodersfunc[i] = funcs;
			plugindecodersplugin[i] = plug;
			return true;
		}
	}
	return false;
}
/*funcs==null closes ALL decoders from this plugin*/
qboolean Media_UnregisterDecoder(struct plugin_s *plug, media_decoder_funcs_t *funcs)
{
	qboolean success = true;
	int i;
	static media_decoder_funcs_t deadfuncs;
	struct plugin_s *oldplug = currentplug;
	cin_t *cin, *next;

	for (i = 0; i < sizeof(plugindecodersfunc)/sizeof(plugindecodersfunc[0]); i++)
	{
		if (plugindecodersfunc[i] == funcs || (!funcs && plugindecodersplugin[i] == plug))
		{
			//kill any cinematics currently using that decoder
			for (cin = active_cin_plugins; cin; cin = next)
			{
				next = cin->plugin.next;

				if (cin->plugin.plug == plug && cin->plugin.funcs == plugindecodersfunc[i])
				{
					//we don't kill the engine's side of it, not just yet anyway.
					currentplug = cin->plugin.plug;
					if (cin->plugin.funcs->shutdown)
						cin->plugin.funcs->shutdown(cin->plugin.ctx);
					cin->plugin.funcs = &deadfuncs;
					cin->plugin.plug = NULL;
					cin->plugin.ctx = NULL;
				}
			}
			currentplug = oldplug;


			plugindecodersfunc[i] = NULL;
			plugindecodersplugin[i] = NULL;
			if (funcs)
				return success;
		}
	}

	if (!funcs)
	{
		static media_decoder_funcs_t deadfuncs;
		struct plugin_s *oldplug = currentplug;
		cin_t *cin, *next;

		for (cin = active_cin_plugins; cin; cin = next)
		{
			next = cin->plugin.next;

			if (cin->plugin.plug == plug)
			{
				//we don't kill the engine's side of it, not just yet anyway.
				currentplug = cin->plugin.plug;
				if (cin->plugin.funcs->shutdown)
					cin->plugin.funcs->shutdown(cin->plugin.ctx);
				cin->plugin.funcs = &deadfuncs;
				cin->plugin.plug = NULL;
				cin->plugin.ctx = NULL;
			}
		}
		currentplug = oldplug;
	}
	return success;
}

static qboolean Media_Plugin_DecodeFrame (cin_t *cin, qboolean nosound, qboolean forcevideo, double mediatime, void (QDECL *uploadtexture)(void *ctx, uploadfmt_t fmt, int width, int height, void *data, void *palette), void *ctx)
{
	qboolean okay;
	struct plugin_s *oldplug = currentplug;
	if (!cin->plugin.funcs->decodeframe)
		return false;	//plugin closed or something

	currentplug = cin->plugin.plug;
	okay = cin->plugin.funcs->decodeframe(cin->plugin.ctx, nosound, forcevideo, mediatime, uploadtexture, ctx);
	currentplug = oldplug;
	return okay;
}
static void Media_Plugin_Shutdown(cin_t *cin)
{
	struct plugin_s *oldplug = currentplug;
	currentplug = cin->plugin.plug;
	if (cin->plugin.funcs->shutdown)
		cin->plugin.funcs->shutdown(cin->plugin.ctx);
	currentplug = oldplug;

	if (cin->plugin.prev)
		cin->plugin.prev->plugin.next = cin->plugin.next;
	else
		active_cin_plugins = cin->plugin.next;
	if (cin->plugin.next)
		cin->plugin.next->plugin.prev = cin->plugin.prev;
}
static void Media_Plugin_Rewind(cin_t *cin)
{
	struct plugin_s *oldplug = currentplug;
	currentplug = cin->plugin.plug;
	if (cin->plugin.funcs->rewind)
		cin->plugin.funcs->rewind(cin->plugin.ctx);
	currentplug = oldplug;
}

void Media_Plugin_MoveCursor(cin_t *cin, float posx, float posy)
{
	struct plugin_s *oldplug = currentplug;
	currentplug = cin->plugin.plug;
	if (cin->plugin.funcs->cursormove)
		cin->plugin.funcs->cursormove(cin->plugin.ctx, posx, posy);
	currentplug = oldplug;
}
void Media_Plugin_KeyPress(cin_t *cin, int code, int unicode, int event)
{
	struct plugin_s *oldplug = currentplug;
	currentplug = cin->plugin.plug;
	if (cin->plugin.funcs->key)
		cin->plugin.funcs->key(cin->plugin.ctx, code, unicode, event);
	currentplug = oldplug;
}
qboolean Media_Plugin_SetSize(cin_t *cin, int width, int height)
{
	qboolean result = false;
	struct plugin_s *oldplug = currentplug;
	currentplug = cin->plugin.plug;
	if (cin->plugin.funcs->setsize)
		result = cin->plugin.funcs->setsize(cin->plugin.ctx, width, height);
	currentplug = oldplug;
	return result;
}
void Media_Plugin_GetSize(cin_t *cin, int *width, int *height, float *aspect)
{
	struct plugin_s *oldplug = currentplug;
	currentplug = cin->plugin.plug;
	if (cin->plugin.funcs->getsize)
		cin->plugin.funcs->getsize(cin->plugin.ctx, width, height);
	currentplug = oldplug;
}
void Media_Plugin_ChangeStream(cin_t *cin, const char *streamname)
{
	struct plugin_s *oldplug = currentplug;
	currentplug = cin->plugin.plug;
	if (cin->plugin.funcs->changestream)
		cin->plugin.funcs->changestream(cin->plugin.ctx, streamname);
	currentplug = oldplug;
}
qboolean Media_Plugin_GetProperty(cin_t *cin, const char *propname, char *data, size_t *datasize)
{
	qboolean ret = false;
	struct plugin_s *oldplug = currentplug;
	currentplug = cin->plugin.plug;
	if (cin->plugin.funcs->getproperty)
		ret = cin->plugin.funcs->getproperty(cin->plugin.ctx, propname, data, datasize);
	currentplug = oldplug;
	return ret;
}

cin_t *Media_Plugin_TryLoad(char *name)
{
	cin_t *cin;
	int i;
	media_decoder_funcs_t *funcs = NULL;
	struct plugin_s *plug = NULL;
	void *ctx = NULL;
	struct plugin_s *oldplug = currentplug;
	for (i = 0; i < sizeof(plugindecodersfunc)/sizeof(plugindecodersfunc[0]); i++)
	{
		funcs = plugindecodersfunc[i];
		if (funcs)
		{
			plug = plugindecodersplugin[i];
			currentplug = plug;
			ctx = funcs->createdecoder(name);
			if (ctx)
				break;
		}
	}
	currentplug = oldplug;

	if (ctx)
	{
		cin = Z_Malloc(sizeof(cin_t));
		cin->plugin.funcs = funcs;
		cin->plugin.plug = plug;
		cin->plugin.ctx = ctx;
		cin->plugin.next = active_cin_plugins;
		cin->plugin.prev = NULL;
		if (cin->plugin.next)
			cin->plugin.next->plugin.prev = cin;
		active_cin_plugins = cin;
		cin->decodeframe = Media_Plugin_DecodeFrame;
		cin->shutdown = Media_Plugin_Shutdown;
		cin->rewind = Media_Plugin_Rewind;

		if (funcs->cursormove)
			cin->cursormove		= Media_Plugin_MoveCursor;
		if (funcs->key)
			cin->key			= Media_Plugin_KeyPress;
		if (funcs->setsize)
			cin->setsize		= Media_Plugin_SetSize;
		if (funcs->getsize)
			cin->getsize		= Media_Plugin_GetSize;
		if (funcs->changestream)
			cin->changestream	= Media_Plugin_ChangeStream;
		if (funcs->getproperty)
			cin->getproperty	= Media_Plugin_GetProperty;

		return cin;
	}
	return NULL;
}
#endif
//Plugin Support
//////////////////////////////////////////////////////////////////////////////////
//Quake3 RoQ Support

#ifdef Q3CLIENT
#include "roq.h"
static void Media_Roq_Shutdown(struct cin_s *cin)
{
	roq_close(cin->roq.roqfilm);
	cin->roq.roqfilm=NULL;
}

static qboolean Media_Roq_DecodeFrame (cin_t *cin, qboolean nosound, qboolean forcevideo, double mediatime, void (QDECL *uploadtexture)(void *ctx, uploadfmt_t fmt, int width, int height, void *data, void *palette), void *ctx)
{
	qboolean doupdate = forcevideo;

	//seeking could probably be done a bit better...
	//key frames or something, I dunno
	while (mediatime >= cin->roq.nextframetime)
	{
		switch (roq_read_frame(cin->roq.roqfilm)) //0 if end, -1 if error, 1 if success
		{
		default:	//error
		case 0:		//eof
			if (!doupdate)
				return false;
			break;
		case 1:
			break;	//success
		}
		cin->roq.nextframetime += 1.0/30;
		doupdate = true;
	}

	if (doupdate)
	{
	//#define LIMIT(x) ((x)<0xFFFF)?(x)>>16:0xFF;
#define LIMIT(x) ((((x) > 0xffffff) ? 0xff0000 : (((x) <= 0xffff) ? 0 : (x) & 0xff0000)) >> 16)
		unsigned char *pa=cin->roq.roqfilm->y[0];
		unsigned char *pb=cin->roq.roqfilm->u[0];
		unsigned char *pc=cin->roq.roqfilm->v[0];
		int pix=0;
		int num_columns=(cin->roq.roqfilm->width)>>1;
		int num_rows=cin->roq.roqfilm->height;
		int y;
		int x;

		qbyte *framedata;

		if (cin->roq.roqfilm->num_frames)
			cin->filmpercentage = cin->roq.roqfilm->frame_num / cin->roq.roqfilm->num_frames;
		else
			cin->filmpercentage = 0;

		{
			framedata = cin->framedata;

			for(y = 0; y < num_rows; ++y)	//roq playing doesn't give nice data. It's still fairly raw.
			{										//convert it properly.
				for(x = 0; x < num_columns; ++x)
				{

					int r, g, b, y1, y2, u, v, t;
					y1 = *(pa++); y2 = *(pa++);
					u = pb[x] - 128;
					v = pc[x] - 128;

					y1 <<= 16;
					y2 <<= 16;
					r = 91881 * v;
					g = -22554 * u + -46802 * v;
					b = 116130 * u;

					t=r+y1;
					framedata[pix] =(unsigned char) LIMIT(t);
					t=g+y1;
					framedata[pix+1] =(unsigned char) LIMIT(t);
					t=b+y1;
					framedata[pix+2] =(unsigned char) LIMIT(t);

					t=r+y2;
					framedata[pix+4] =(unsigned char) LIMIT(t);
					t=g+y2;
					framedata[pix+5] =(unsigned char) LIMIT(t);
					t=b+y2;
					framedata[pix+6] =(unsigned char) LIMIT(t);
					pix+=8;

				}
				if(y & 0x01) { pb += num_columns; pc += num_columns; }
			}
		}

		uploadtexture(ctx, TF_RGBX32, cin->roq.roqfilm->width, cin->roq.roqfilm->height, cin->framedata, NULL);

		if (!nosound)
		{
			while (cin->roq.roqfilm->audio_channels && S_HaveOutput() && cin->roq.roqfilm->aud_pos < cin->roq.roqfilm->vid_pos)
			{
				if (roq_read_audio(cin->roq.roqfilm)>0)		
					S_RawAudio(-1, cin->roq.roqfilm->audio, 22050, cin->roq.roqfilm->audio_size/cin->roq.roqfilm->audio_channels, cin->roq.roqfilm->audio_channels, 2, volume.value );
				else
					break;
			}
		}
	}
	return true;
}

static cin_t *Media_RoQ_TryLoad(char *name)
{
	cin_t *cin;
	roq_info *roqfilm;
	if (strchr(name, ':'))
		return NULL;

	if ((roqfilm = roq_open(name)))
	{
		cin = Z_Malloc(sizeof(cin_t));
		cin->decodeframe = Media_Roq_DecodeFrame;
		cin->shutdown = Media_Roq_Shutdown;

		cin->roq.roqfilm = roqfilm;

		cin->framedata = BZ_Malloc(roqfilm->width*roqfilm->height*4);
		return cin;
	}
	return NULL;
}
#endif

//Quake3 RoQ Support
//////////////////////////////////////////////////////////////////////////////////
//Static Image Support

#ifndef MINIMAL
static void Media_Static_Shutdown(struct cin_s *cin)
{
	BZ_Free(cin->image.filmimage);
	cin->image.filmimage = NULL;
}

static qboolean Media_Static_DecodeFrame (cin_t *cin, qboolean nosound, qboolean forcevideo, double mediatime, void (QDECL *uploadtexture)(void *ctx, uploadfmt_t fmt, int width, int height, void *data, void *palette), void *ctx)
{
	if (forcevideo)
		uploadtexture(ctx, TF_RGBA32, cin->image.imagewidth, cin->image.imageheight, cin->image.filmimage, NULL);
	return true;
}

static cin_t *Media_Static_TryLoad(char *name)
{
	cin_t *cin;
	char *dot = strrchr(name, '.');

	if (dot && (!strcmp(dot, ".pcx") || !strcmp(dot, ".tga") || !strcmp(dot, ".png") || !strcmp(dot, ".jpg")))
	{
		qbyte *staticfilmimage;
		int imagewidth;
		int imageheight;
		uploadfmt_t format = PTI_RGBA8;

		int fsize;
		char fullname[MAX_QPATH];
		qbyte *file;

		Q_snprintfz(fullname, sizeof(fullname), "%s", name);
		fsize = FS_LoadFile(fullname, (void **)&file);
		if (!file)
		{
			Q_snprintfz(fullname, sizeof(fullname), "pics/%s", name);
			fsize = FS_LoadFile(fullname, (void **)&file);
			if (!file)
				return NULL;
		}

		if ((staticfilmimage = ReadPCXFile(file, fsize, &imagewidth, &imageheight)) ||	//convert to 32 rgba if not corrupt
			(staticfilmimage = ReadTargaFile(file, fsize, &imagewidth, &imageheight, &format, false, PTI_RGBA8)) ||
#ifdef AVAIL_JPEGLIB
			(staticfilmimage = ReadJPEGFile(file, fsize, &imagewidth, &imageheight)) ||
#endif
#ifdef AVAIL_PNGLIB
			(staticfilmimage = ReadPNGFile(fullname, file, fsize, &imagewidth, &imageheight, &format)) ||
#endif
			0)
		{
			FS_FreeFile(file);	//got image data
		}
		else
		{
			FS_FreeFile(file);	//got image data
			Con_Printf("Static cinematic format not supported.\n");	//not supported format
			return NULL;
		}

		cin = Z_Malloc(sizeof(cin_t));
		cin->decodeframe = Media_Static_DecodeFrame;
		cin->shutdown = Media_Static_Shutdown;

		cin->image.filmimage = staticfilmimage;
		cin->image.imagewidth = imagewidth;
		cin->image.imageheight = imageheight;

		return cin;
	}
	return NULL;
}
#endif

//Static Image Support
//////////////////////////////////////////////////////////////////////////////////
//Quake2 CIN Support

#ifdef Q2CLIENT
//fixme: this code really shouldn't be in this file.
static void Media_Cin_Shutdown(struct cin_s *cin)
{
	CIN_StopCinematic(cin->q2cin.cin);
}
static void Media_Cin_Rewind(struct cin_s *cin)
{
	CIN_Rewind(cin->q2cin.cin);
}

static qboolean Media_Cin_DecodeFrame(cin_t *cin, qboolean nosound, qboolean forcevideo, double mediatime, void (QDECL *uploadtexture)(void *ctx, uploadfmt_t fmt, int width, int height, void *data, void *palette), void *ctx)
{
	qbyte *outdata;
	int outwidth;
	int outheight;
	qbyte *outpalette;

	switch (CIN_RunCinematic(cin->q2cin.cin, mediatime, &outdata, &outwidth, &outheight, &outpalette))
	{
	default:
	case 0:
		return false;
	case 1:
		break;
	case 2:
		if (!forcevideo)
			return true;
		break;
	}

	uploadtexture(ctx, TF_8PAL24, outwidth, outheight, outdata, outpalette);
	return true;
}

static cin_t *Media_Cin_TryLoad(char *name)
{
	struct cinematics_s *q2cin;
	cin_t *cin;
	char *dot = strrchr(name, '.');

	if (dot && (!strcmp(dot, ".cin")))
	{
		q2cin = CIN_PlayCinematic(name);
		if (q2cin)
		{
			cin = Z_Malloc(sizeof(cin_t));
			cin->q2cin.cin = q2cin;
			cin->decodeframe = Media_Cin_DecodeFrame;
			cin->shutdown = Media_Cin_Shutdown;
			cin->rewind = Media_Cin_Rewind;
			return cin;
		}
	}

	return NULL;
}
#endif

//Quake2 CIN Support
//////////////////////////////////////////////////////////////////////////////////

qboolean Media_PlayingFullScreen(void)
{
	return videoshader!=NULL;
}

void Media_ShutdownCin(cin_t *cin)
{
	if (!cin)
		return;

	if (cin->shutdown)
		cin->shutdown(cin);

	if (TEXVALID(cin->texture))
		Image_UnloadTexture(cin->texture);

	if (cin->framedata)
	{
		BZ_Free(cin->framedata);
		cin->framedata = NULL;
	}

	Z_Free(cin);

	Z_Free(cin_prop_buf);
	cin_prop_buf = NULL;
	cin_prop_bufsize = 0;
}

cin_t *Media_StartCin(char *name)
{
	cin_t *cin = NULL;

	if (!name || !*name)	//clear only.
		return NULL;

#ifndef MINIMAL
	if (!cin)
		cin = Media_Static_TryLoad(name);
#endif
#ifdef Q2CLIENT
	if (!cin)
		cin = Media_Cin_TryLoad(name);
#endif
#ifdef Q3CLIENT
	if (!cin)
		cin = Media_RoQ_TryLoad(name);
#endif
#ifdef HAVE_API_VFW
	if (!cin)
		cin = Media_WinAvi_TryLoad(name);
#endif
#ifdef PLUGINS
	if (!cin)
		cin = Media_Plugin_TryLoad(name);
#endif
	if (cin)
		cin->filmstarttime = realtime;
	return cin;
}

struct pendingfilms_s
{
	struct pendingfilms_s *next;
	char name[1];
} *pendingfilms;
qboolean Media_BeginNextFilm(void)
{
	cin_t *cin;
	char sname[MAX_QPATH];
	struct pendingfilms_s *p;

	if (!pendingfilms)
		return false;
	p = pendingfilms;
	pendingfilms = p->next;
	snprintf(sname, sizeof(sname), "cinematic/%s", p->name);

	if (!qrenderer)
	{
		Z_Free(p);
		return false;
	}

	videoshader = R_RegisterCustom(sname, SUF_NONE, Shader_DefaultCinematic, p->name);

	cin = R_ShaderGetCinematic(videoshader);
	if (cin)
	{
		Media_SetState(cin, CINSTATE_PLAY);
		Media_Send_Reset(cin);
		if (cin->changestream)
			cin->changestream(cin, "cmd:focus");
	}
	else
	{
		Con_Printf("Unable to play cinematic %s\n", p->name);
		R_UnloadShader(videoshader);
		videoshader = NULL;
	}
	Z_Free(p);
	return !!videoshader;
}
qboolean Media_StopFilm(qboolean all)
{
	if (!pendingfilms && !videoshader)
		return false;	//nothing to do

	if (all)
	{
		struct pendingfilms_s *p;
		while(pendingfilms)
		{
			p = pendingfilms;
			pendingfilms = p->next;
			Z_Free(p);
		}
	}
	if (videoshader)
	{
		R_UnloadShader(videoshader);
		videoshader = NULL;

		S_RawAudio(-1, NULL, 0, 0, 0, 0, 0);
	}

	while (pendingfilms && !videoshader)
	{
		if (Media_BeginNextFilm())
			break;
	}

	//for q2 cinematic-maps.
	//q2 sends 'nextserver' when the client's cinematics end so that the game can progress to the next map.
	//qc might want to make use of it too, but its probably best to just send a playfilm command at the start of the map and then just wait it out. maybe treat nextserver as an unpause request.
	if (!videoshader && cls.state == ca_active)
	{
		CL_SendClientCommand(true, "nextserver %i", cl.servercount);
	}
	return true;
}
qboolean Media_PlayFilm(char *name, qboolean enqueue)
{
	if (!enqueue || !*name)
		Media_StopFilm(true);

	if (*name)
	{
		struct pendingfilms_s **p;
		for (p = &pendingfilms; *p; p = &(*p)->next)
			;
		(*p) = Z_Malloc(sizeof(**p) + strlen(name));
		strcpy((*p)->name, name);

		while (pendingfilms && !videoshader)
		{
			if (Media_BeginNextFilm())
				break;
		}
	}

	if (videoshader)
	{
#ifdef HAVE_CDPLAYER
		CDAudio_Stop();
#endif
		SCR_EndLoadingPlaque();

		if (Key_Dest_Has(kdm_emenu))
			Key_Dest_Remove(kdm_emenu);
#ifdef MENU_DAT
		if (Key_Dest_Has(kdm_gmenu))
			MP_Toggle(0);
#endif
		if (!Key_Dest_Has(kdm_console))
			scr_con_current=0;
		return true;
	}
	else
		return false;
}
qboolean Media_ShowFilm(void)
{
	if (videoshader)
	{
		cin_t *cin = R_ShaderGetCinematic(videoshader);
		if (cin && cin->playstate == CINSTATE_ENDED)
		{
			Media_StopFilm(false);
		}
		else if (cin)
		{
			int cw, ch;
			float aspect;
			if (cin->cursormove)
				cin->cursormove(cin, mousecursor_x/(float)vid.width, mousecursor_y/(float)vid.height);
			if (cin->setsize)
				cin->setsize(cin, vid.pixelwidth, vid.pixelheight);

			//FIXME: should have a proper aspect ratio setting. RoQ files are always power of two, which makes things ugly.
			if (cin->getsize)
				cin->getsize(cin, &cw, &ch, &aspect);
			else
			{
				cw = 4;
				ch = 3;
			}

			R2D_Letterbox(0, 0, vid.fbvwidth, vid.fbvheight, videoshader, cw, ch);

			SCR_SetUpToDrawConsole();
			if  (scr_con_current)
				SCR_DrawConsole (false);
			return true;
		}
	}
	return false;
}

#ifndef SERVERONLY
void QDECL Media_UpdateTexture(void *ctx, uploadfmt_t fmt, int width, int height, void *data, void *palette)
{
	cin_t *cin = ctx;
	if (!TEXVALID(cin->texture))
		TEXASSIGN(cin->texture, Image_CreateTexture("***cin***", NULL, IF_CLAMP|IF_NOMIPMAP));
	Image_Upload(cin->texture, fmt, data, palette, width, height, IF_CLAMP|IF_NOMIPMAP|IF_NOGAMMA);
}
texid_tf Media_UpdateForShader(cin_t *cin)
{
	float mediatime;
	qboolean force = false;
	if (!cin)	//caller fucked up.
		return r_nulltex;

	if (cin->playstate == CINSTATE_FLUSHED)
	{
		cin->playstate = CINSTATE_PLAY;
		mediatime = 0;
		cin->filmstarttime = realtime;
	}
	else if (cin->playstate == CINSTATE_INVALID)
	{
		cin->playstate = CINSTATE_LOOP;
		mediatime = 0;
		cin->filmstarttime = realtime;
	}
	else if (cin->playstate == CINSTATE_ENDED)
		mediatime = 0;	//if we reach the end of the video, we give up and just show the first frame for subsequent frames
	else if (cin->playstate == CINSTATE_PAUSE)
		mediatime = cin->filmstarttime;
	else
		mediatime = realtime - cin->filmstarttime;

	if (!TEXVALID(cin->texture))
	{
		force = true;
	}

	if (!cin->decodeframe(cin, false, force, mediatime, Media_UpdateTexture, cin))
	{
		//we got eof / error
		if (cin->playstate != CINSTATE_LOOP)
			Media_SetState(cin, CINSTATE_ENDED);
		if (cin->rewind)
		{
			Media_Send_Reset(cin);
			mediatime = 0;
			if (!cin->decodeframe(cin, true, force, mediatime, Media_UpdateTexture, cin))
				return r_nulltex;
		}
	}

	return cin->texture;
}
#endif

void Media_Send_KeyEvent(cin_t *cin, int button, int unicode, int event)
{
	if (!cin)
		cin = R_ShaderGetCinematic(videoshader);
	if (!cin)
		return;
	if (cin->key)
		cin->key(cin, button, unicode, event);
	else if (button == K_SPACE && !event)
	{
		if (cin->playstate == CINSTATE_PAUSE)
			Media_SetState(cin, CINSTATE_PLAY);
		else
			Media_SetState(cin, CINSTATE_PAUSE);
	}
	else if (button == K_BACKSPACE && !event)
	{
		Media_Send_Reset(cin);
	}
	else if ((button == K_LEFTARROW || button == K_KP_LEFTARROW || button == K_GP_DPAD_LEFT) && !event)
		cin->filmstarttime += (cin->playstate == CINSTATE_PAUSE)?-10:10;
	else if ((button == K_RIGHTARROW || button == K_KP_RIGHTARROW || button == K_GP_DPAD_RIGHT) && !event)
		cin->filmstarttime -= (cin->playstate == CINSTATE_PAUSE)?-10:10;
}
void Media_Send_MouseMove(cin_t *cin, float x, float y)
{
	if (!cin)
		cin = R_ShaderGetCinematic(videoshader);
	if (!cin || !cin->cursormove)
		return;
	cin->cursormove(cin, x, y);
}
void Media_Send_Resize(cin_t *cin, int x, int y)
{
	if (!cin)
		cin = R_ShaderGetCinematic(videoshader);
	if (!cin || !cin->setsize)
		return;
	cin->setsize(cin, x, y);
}
void Media_Send_GetSize(cin_t *cin, int *x, int *y, float *aspect)
{
	*x = 0;
	*y = 0;
	*aspect = 0;
	if (!cin)
		cin = R_ShaderGetCinematic(videoshader);
	if (!cin || !cin->getsize)
		return;
	cin->getsize(cin, x, y, aspect);
}
void Media_Send_Reset(cin_t *cin)
{
	if (!cin)
		return;
	if (cin->playstate == CINSTATE_PAUSE)
		cin->filmstarttime = 0;	//fixed on resume
	else
		cin->filmstarttime = realtime;
	if (cin->rewind)
		cin->rewind(cin);
}
void Media_Send_Command(cin_t *cin, const char *command)
{
	if (!cin)
		cin = R_ShaderGetCinematic(videoshader);
	if (cin && cin->changestream)
		cin->changestream(cin, command);
	else if (cin && !strcmp(command, "cmd:rewind"))
		Media_Send_Reset(cin);
}
const char *Media_Send_GetProperty(cin_t *cin, const char *key)
{
	if (!cin)
		cin = R_ShaderGetCinematic(videoshader);
	if (cin && cin->getproperty)
	{
		size_t needsize = 0;
		if (cin->getproperty(cin, key, NULL, &needsize))
		{
			if (needsize+1 > cin_prop_bufsize)
			{
				cin_prop_buf = BZ_Realloc(cin_prop_buf, needsize+1);
				cin_prop_bufsize = needsize+1;
			}
			cin_prop_buf[needsize] = 0;
			if (cin->getproperty(cin, key, cin_prop_buf, &needsize))
				return cin_prop_buf;
		}
	}

	return NULL;
}
void Media_SetState(cin_t *cin, cinstates_t newstate)
{
	if (cin->playstate == newstate)
		return;

	if (newstate == CINSTATE_FLUSHED || newstate == CINSTATE_ENDED)
		cin->filmstarttime = realtime;	//these technically both rewind it.
	else if (newstate == CINSTATE_PAUSE)
		cin->filmstarttime = realtime - cin->filmstarttime;
	else if (cin->playstate == CINSTATE_PAUSE)
		cin->filmstarttime = realtime - cin->filmstarttime;

	cin->playstate = newstate;
}
cinstates_t Media_GetState(cin_t *cin)
{
	return cin->playstate;
}

void Media_PlayFilm_f (void)
{
	int i;
	if (Cmd_Argc() < 2)
	{
		Con_Printf("playfilm <filename>");
	}
	if (!strcmp(Cmd_Argv(0), "cinematic"))
		Media_PlayFilm(va("video/%s", Cmd_Argv(1)), false);
	else
	{
		Media_PlayFilm(Cmd_Argv(1), false);
		for (i = 2; i < Cmd_Argc(); i++)
			Media_PlayFilm(Cmd_Argv(i), true);
	}
}

void Media_PlayVideoWindowed_f (void)
{
	char *videomap = Cmd_Argv(1);
	shader_t *s;
	console_t *con;
	if (!qrenderer)
		return;
	s = R_RegisterCustom(va("consolevid_%s", videomap), SUF_NONE, Shader_DefaultCinematic, videomap);
	if (!R_ShaderGetCinematic(s))
	{
		R_UnloadShader(s);
		Con_Printf("Unable to load video %s\n", videomap);
		return;
	}

	con = Con_Create(videomap, 0);
	if (!con)
		return;
	con->parseflags = PFS_FORCEUTF8;
	con->flags = CONF_ISWINDOW;
	con->wnd_x = vid.width/4;
	con->wnd_y = vid.height/4;
	con->wnd_w = vid.width/2;
	con->wnd_h = vid.height/2;
	con->linebuffered = NULL;

	Q_strncpyz(con->backimage, "", sizeof(con->backimage));
	if (con->backshader)
		R_UnloadShader(con->backshader);
	con->backshader = s;

	Con_SetActive(con);
}
#else
qboolean Media_ShowFilm(void){return false;}
#endif	//HAVE_MEDIA_DECODER














#ifdef HAVE_MEDIA_ENCODER

soundcardinfo_t *capture_fakesounddevice;

double captureframeinterval;	//interval between video frames
double capturelastvideotime;	//time of last video frame
int captureframe;
fbostate_t capturefbo;
int captureoldfbo;
qboolean capturingfbo;
texid_t	capturetexture;
qboolean captureframeforce;

#if defined(GLQUAKE) && !defined(GLESONLY)
#define GLQUAKE_PBOS
#endif
struct
{
#ifdef GLQUAKE_PBOS
	int pbo_handle;
#endif
	enum uploadfmt format;
	int stride;
	int width;
	int height;
} offscreen_queue[4];	//ringbuffer of offscreen_captureframe...captureframe
int offscreen_captureframe;
enum uploadfmt offscreen_format;

#define CAPTURECODECDESC_DEFAULT	"tga"
#ifdef HAVE_API_VFW
#define CAPTUREDRIVERDESC_AVI "avi: capture directly to avi (capturecodec should be a fourcc value).\n"
#define CAPTURECODECDESC_AVI "With (win)avi, this should be a fourcc code like divx or xvid, may be blank for raw video.\n"
#else
#define CAPTUREDRIVERDESC_AVI
#define CAPTURECODECDESC_AVI
#endif

qboolean capturepaused;
extern cvar_t vid_conautoscale;
cvar_t capturerate = CVARD("capturerate", "30", "The framerate of the video to capture");
cvar_t capturewidth = CVARD("capturedemowidth", "0", "When using capturedemo, this specifies the width of the FBO image used. Can be larger than your physical monitor.");
cvar_t captureheight = CVARD("capturedemoheight", "0", "When using capturedemo, this specifies the height of the FBO image used.");
cvar_t capturedriver = CVARD("capturedriver", "", "The driver to use to capture the demo. Use the capture command with no arguments for a list of drivers.");
cvar_t capturecodec = CVARD("capturecodec", CAPTURECODECDESC_DEFAULT, "the compression/encoding codec to use.\n"CAPTURECODECDESC_AVI"With raw capturing, this should be one of tga,png,jpg,pcx (ie: screenshot extensions).");
cvar_t capturesound = CVARD("capturesound", "1", "Enables the capturing of game voice. If not using capturedemo, this can be combined with cl_voip_test to capture your own voice.");
cvar_t capturesoundchannels = CVAR("capturesoundchannels", "2");
cvar_t capturesoundbits = CVAR("capturesoundbits", "16");
cvar_t capturemessage = CVAR("capturemessage", "");
cvar_t capturethrottlesize = CVARD("capturethrottlesize", "0", "If set, capturing will slow down significantly if there is less disk space available than this cvar (in mb). This is useful when recording a stream to (ram)disk while another program is simultaneously consuming frames.");
qboolean recordingdemo;

media_encoder_funcs_t *currentcapture_funcs;
void *currentcapture_ctx;


#if 1
/*screenshot capture*/
struct capture_raw_ctx
{
	int frames;
	enum fs_relative fsroot;
	char videonameprefix[MAX_QPATH];
	char videonameextension[16];
	vfsfile_t *audio;
};

qboolean FS_FixPath(char *path, size_t pathsize);
static void *QDECL capture_raw_begin (char *streamname, int videorate, int width, int height, int *sndkhz, int *sndchannels, int *sndbits)
{
	struct capture_raw_ctx *ctx = Z_Malloc(sizeof(*ctx));

	if (!strcmp(capturecodec.string, "png") || !strcmp(capturecodec.string, "jpeg") || !strcmp(capturecodec.string, "jpg") || !strcmp(capturecodec.string, "bmp") || !strcmp(capturecodec.string, "pcx") || !strcmp(capturecodec.string, "tga"))
		Q_strncpyz(ctx->videonameextension, capturecodec.string, sizeof(ctx->videonameextension));
	else
		Q_strncpyz(ctx->videonameextension, "tga", sizeof(ctx->videonameextension));

	if (!FS_NativePath(va("%s", streamname), FS_GAMEONLY, ctx->videonameprefix, sizeof(ctx->videonameprefix)))
	{
		Z_Free(ctx);
		return NULL;
	}
	if (!FS_FixPath(ctx->videonameprefix, sizeof(ctx->videonameprefix)))
	{
		Z_Free(ctx);
		return NULL;
	}
	ctx->fsroot = FS_SYSTEM;
	ctx->audio = NULL;
	if (*sndkhz)
	{
		char filename[MAX_OSPATH];
		if (*sndbits < 8)
			*sndbits = 8;
		if (*sndbits != 8)
			*sndbits = 16;
		if (*sndchannels > 6)
			*sndchannels = 6;
		if (*sndchannels < 1)
			*sndchannels = 1;
		Q_snprintfz(filename, sizeof(filename), "%saudio_%ichan_%ikhz_%ib.raw", ctx->videonameprefix, *sndchannels, *sndkhz/1000, *sndbits);
		FS_CreatePath(filename, ctx->fsroot);
		ctx->audio = FS_OpenVFS(filename, "wb", ctx->fsroot);
	}
	if (!ctx->audio)
	{
		*sndkhz = 0;
		*sndchannels = 0;
		*sndbits = 0;
	}
	return ctx;
}
static void QDECL capture_raw_video (void *vctx, int frame, void *data, int stride, int width, int height, enum uploadfmt fmt)
{
	struct capture_raw_ctx *ctx = vctx;
	char filename[MAX_OSPATH];
	ctx->frames = frame+1;
	Q_snprintfz(filename, sizeof(filename), "%s%8.8i.%s", ctx->videonameprefix, frame, ctx->videonameextension);
	if (SCR_ScreenShot(filename, ctx->fsroot, &data, 1, stride, width, height, fmt, true))
	{
		Sys_Sleep(1);
		if (SCR_ScreenShot(filename, ctx->fsroot, &data, 1, stride, width, height, fmt, true))
			Con_DPrintf("Error writing frame %s\n", filename);
	}

	if (capturethrottlesize.value)
	{
		char base[MAX_QPATH];
		Q_strncpyz(base, ctx->videonameprefix, sizeof(base));
		if (FS_NativePath(base, ctx->fsroot, filename, sizeof(filename)))
		{
			quint64_t diskfree = 0;
			if (Sys_GetFreeDiskSpace(filename, &diskfree) && diskfree < (quint64_t)1024*1024*capturethrottlesize.value)
				Sys_Sleep(1);	//throttle
			else
			{
				Con_Printf("%s: unable to query free disk space. Disabling\n", capturethrottlesize.name);
				capturethrottlesize.ival = capturethrottlesize.value = 0;
			}
		}
	}
}
static void QDECL capture_raw_audio (void *vctx, void *data, int bytes)
{
	struct capture_raw_ctx *ctx = vctx;

	if (ctx->audio)
		VFS_WRITE(ctx->audio, data, bytes);
}
static void QDECL capture_raw_end (void *vctx)
{
	struct capture_raw_ctx *ctx = vctx;
	if (ctx->audio)
		VFS_CLOSE(ctx->audio);
	Con_Printf("%d video frames captured\n", ctx->frames);
	Z_Free(ctx);
}
static media_encoder_funcs_t capture_raw =
{
	sizeof(media_encoder_funcs_t),
	"raw",
	"Saves the video as a series of image files within the named sub directory, one for each frame. Audio is recorded as raw pcm.",
	NULL,
	capture_raw_begin,
	capture_raw_video,
	capture_raw_audio,
	capture_raw_end
};
#endif
#if defined(HAVE_API_VFW)

/*screenshot capture*/
struct capture_avi_ctx
{
	PAVIFILE file;
	#define avi_video_stream(ctx) (ctx->codec_fourcc?ctx->compressed_video_stream:ctx->uncompressed_video_stream)
	PAVISTREAM uncompressed_video_stream;
	PAVISTREAM compressed_video_stream;
	PAVISTREAM uncompressed_audio_stream;
	WAVEFORMATEX wave_format;
	unsigned long codec_fourcc;

	int audio_frame_counter;
};

static void QDECL capture_avi_end(void *vctx)
{
	struct capture_avi_ctx *ctx = vctx;

	if (ctx->uncompressed_video_stream)	qAVIStreamRelease(ctx->uncompressed_video_stream);
	if (ctx->compressed_video_stream)	qAVIStreamRelease(ctx->compressed_video_stream);
	if (ctx->uncompressed_audio_stream)	qAVIStreamRelease(ctx->uncompressed_audio_stream);
	if (ctx->file)						qAVIFileRelease(ctx->file);
	Z_Free(ctx);
}

static void *QDECL capture_avi_begin (char *streamname, int videorate, int width, int height, int *sndkhz, int *sndchannels, int *sndbits)
{
	struct capture_avi_ctx *ctx = Z_Malloc(sizeof(*ctx));
	HRESULT hr;
	BITMAPINFOHEADER bitmap_info_header;
	AVISTREAMINFOA stream_header;
	FILE *f;
	char aviname[256];
	char nativepath[256];

	char *fourcc = capturecodec.string;

	if (strlen(fourcc) == 4)
		ctx->codec_fourcc = mmioFOURCC(*(fourcc+0), *(fourcc+1), *(fourcc+2), *(fourcc+3));
	else
		ctx->codec_fourcc = 0;

	if (!qAVIStartup())
	{
		Con_Printf("vfw support not available.\n");
		capture_avi_end(ctx);
		return NULL;
	}

	/*convert to foo.avi*/
	COM_StripExtension(streamname, aviname, sizeof(aviname));
	COM_DefaultExtension (aviname, ".avi", sizeof(aviname));
	/*find the system location of that*/
	FS_NativePath(aviname, FS_GAMEONLY, nativepath, sizeof(nativepath));

	//wipe it.
	f = fopen(nativepath, "rb");
	if (f)
	{
		fclose(f);
		unlink(nativepath);
	}

	hr = qAVIFileOpenA(&ctx->file, nativepath, OF_WRITE | OF_CREATE, NULL);
	if (FAILED(hr))
	{
		Con_Printf("Failed to open %s\n", nativepath);
		capture_avi_end(ctx);
		return NULL;
	}


	memset(&bitmap_info_header, 0, sizeof(BITMAPINFOHEADER));
	bitmap_info_header.biSize = 40;
	bitmap_info_header.biWidth = width;
	bitmap_info_header.biHeight = height;
	bitmap_info_header.biPlanes = 1;
	bitmap_info_header.biBitCount = 24;
	bitmap_info_header.biCompression = BI_RGB;
	bitmap_info_header.biSizeImage = width*height * 3;


	memset(&stream_header, 0, sizeof(stream_header));
	stream_header.fccType = streamtypeVIDEO;
	stream_header.fccHandler = ctx->codec_fourcc;
	stream_header.dwScale = 100;
	stream_header.dwRate = (unsigned long)(0.5 + 100.0/captureframeinterval);
	SetRect(&stream_header.rcFrame, 0, 0, width, height);

	hr = qAVIFileCreateStreamA(ctx->file, &ctx->uncompressed_video_stream, &stream_header);
	if (FAILED(hr))
	{
		Con_Printf("Couldn't initialise the stream, check codec\n");
		capture_avi_end(ctx);
		return NULL;
	}

	if (ctx->codec_fourcc)
	{
		AVICOMPRESSOPTIONS opts;
		memset(&opts, 0, sizeof(opts));
		opts.fccType = stream_header.fccType;
		opts.fccHandler = ctx->codec_fourcc;
		// Make the stream according to compression
		hr = qAVIMakeCompressedStream(&ctx->compressed_video_stream, ctx->uncompressed_video_stream, &opts, NULL);
		if (FAILED(hr))
		{
			Con_Printf("AVIMakeCompressedStream failed. check video codec.\n");
			capture_avi_end(ctx);
			return NULL;
		}
	}


	hr = qAVIStreamSetFormat(avi_video_stream(ctx), 0, &bitmap_info_header, sizeof(BITMAPINFOHEADER));
	if (FAILED(hr))
	{
		Con_Printf("AVIStreamSetFormat failed\n");
		capture_avi_end(ctx);
		return NULL;
	}

	if (*sndbits != 8 && *sndbits != 16)
		*sndbits = 8;
	if (*sndchannels < 1 && *sndchannels > 6)
		*sndchannels = 1;

	if (*sndkhz)
	{
		memset(&ctx->wave_format, 0, sizeof(WAVEFORMATEX));
		ctx->wave_format.wFormatTag = WAVE_FORMAT_PCM;
		ctx->wave_format.nChannels = *sndchannels;
		ctx->wave_format.nSamplesPerSec = *sndkhz;
		ctx->wave_format.wBitsPerSample = *sndbits;
		ctx->wave_format.nBlockAlign = ctx->wave_format.wBitsPerSample/8 * ctx->wave_format.nChannels;
		ctx->wave_format.nAvgBytesPerSec = ctx->wave_format.nSamplesPerSec * ctx->wave_format.nBlockAlign;
		ctx->wave_format.cbSize = 0;


		memset(&stream_header, 0, sizeof(stream_header));
		stream_header.fccType = streamtypeAUDIO;
		stream_header.dwScale = ctx->wave_format.nBlockAlign;
		stream_header.dwRate = stream_header.dwScale * (unsigned long)ctx->wave_format.nSamplesPerSec;
		stream_header.dwSampleSize = ctx->wave_format.nBlockAlign;

		//FIXME: be prepared to capture audio to mp3.

		hr = qAVIFileCreateStreamA(ctx->file, &ctx->uncompressed_audio_stream, &stream_header);
		if (FAILED(hr))
		{
			capture_avi_end(ctx);
			return NULL;
		}

		hr = qAVIStreamSetFormat(ctx->uncompressed_audio_stream, 0, &ctx->wave_format, sizeof(WAVEFORMATEX));
		if (FAILED(hr))
		{
			capture_avi_end(ctx);
			return NULL;
		}
	}
	return ctx;
}

static void QDECL capture_avi_video(void *vctx, int frame, void *vdata, int stride, int width, int height, enum uploadfmt fmt)
{
	//vfw api is bottom up.
	struct capture_avi_ctx *ctx = vctx;
	qbyte *data, *in, *out;
	int x, y;

	if (stride < 0)	//if stride is negative, then its bottom-up, but the data pointer is at the start of the buffer (rather than 'first row')
		vdata = (char*)vdata - stride*(height-1);

	//we need to output a packed bottom-up bgr image.

	//switch the input from logical-top-down to bottom-up (regardless of the physical ordering of its rows)
	in = (qbyte*)vdata + stride*(height-1);
	stride = -stride;

	if (fmt == TF_BGR24 && stride == width*-3)
	{	//no work needed!
		data = in;
	}
	else
	{
		int ipx = (fmt == TF_BGR24||fmt == TF_RGB24)?3:4;
		data = out = Hunk_TempAlloc(width*height*3);
		if (fmt == TF_RGB24 || fmt == TF_RGBX32 || fmt == TF_RGBA32)
		{	//byteswap + strip alpha
			for (y = height; y --> 0; out += width*3, in += stride)
			{
				for (x = 0; x < width; x++)
				{
					out[x*3+0] = in[x*ipx+2];
					out[x*3+1] = in[x*ipx+1];
					out[x*3+2] = in[x*ipx+0];
				}
			}
		}
		else if (fmt == TF_BGR24 || fmt == TF_BGRX32 || fmt == TF_BGRA32)
		{	//just strip alpha (or just flip)
			for (y = height; y --> 0; out += width*3, in += stride)
			{
				for (x = 0; x < width; x++)
				{
					out[x*3+0] = in[x*ipx+0];
					out[x*3+1] = in[x*ipx+1];
					out[x*3+2] = in[x*ipx+2];
				}
			}
		}
		else
		{	//probably spammy, but oh well
			Con_Printf("capture_avi_video: Unsupported image format\n");
			return;
		}
	}

	//FIXME: if we're allocating memory anyway, can we not push this to a thread?

	//write it
	if (FAILED(qAVIStreamWrite(avi_video_stream(ctx), frame, 1, data, width*height * 3, ((frame%15) == 0)?AVIIF_KEYFRAME:0, NULL, NULL)))
		Con_DPrintf("Recoring error\n");
}

static void QDECL capture_avi_audio(void *vctx, void *data, int bytes)
{
	struct capture_avi_ctx *ctx = vctx;
	if (ctx->uncompressed_audio_stream)
		qAVIStreamWrite(ctx->uncompressed_audio_stream, ctx->audio_frame_counter++, 1, data, bytes, AVIIF_KEYFRAME, NULL, NULL);
}

static media_encoder_funcs_t capture_avi =
{
	sizeof(media_encoder_funcs_t),
	"avi",
	"Uses Windows' VideoForWindows API to record avi files. Codecs are specified with a fourcc, for instance 'xvid' or 'x264', depending on which ones you have installed.",
	".avi",
	capture_avi_begin,
	capture_avi_video,
	capture_avi_audio,
	capture_avi_end
};
#endif

#ifdef _DEBUG
struct capture_null_context
{
	float starttime;
	int frames;
};
static void QDECL capture_null_end(void *vctx)
{
	struct capture_null_context *ctx = vctx;
	float duration = Sys_DoubleTime() - ctx->starttime;
	Con_Printf("%d video frames ignored, %g secs, %gfps\n", ctx->frames, duration, ctx->frames/duration);
	Z_Free(ctx);
}
static void *QDECL capture_null_begin (char *streamname, int videorate, int width, int height, int *sndkhz, int *sndchannels, int *sndbits)
{
	struct capture_null_context *ctx = Z_Malloc(sizeof(*ctx));
	*sndkhz = 11025;
	*sndchannels = 2;
	*sndbits = 32;	//floats!
	ctx->starttime = Sys_DoubleTime();
	return ctx;
}
static void QDECL capture_null_video(void *vctx, int frame, void *vdata, int stride, int width, int height, enum uploadfmt fmt)
{
	struct capture_null_context *ctx = vctx;
	ctx->frames = frame+1;
}
static void QDECL capture_null_audio(void *vctx, void *data, int bytes)
{
}
static media_encoder_funcs_t capture_null =
{
	sizeof(media_encoder_funcs_t),
	"null",
	"An encoder that doesn't actually encode or write anything, for debugging.",
	".null",
	capture_null_begin,
	capture_null_video,
	capture_null_audio,
	capture_null_end
};
#endif

static media_encoder_funcs_t *pluginencodersfunc[8];
static struct plugin_s *pluginencodersplugin[8];
qboolean Media_RegisterEncoder(struct plugin_s *plug, media_encoder_funcs_t *funcs)
{
	int i;
	if (!funcs || funcs->structsize != sizeof(*funcs))
		return false;
	for (i = 0; i < sizeof(pluginencodersfunc)/sizeof(pluginencodersfunc[0]); i++)
	{
		if (pluginencodersfunc[i] == NULL)
		{
			pluginencodersfunc[i] = funcs;
			pluginencodersplugin[i] = plug;
			return true;
		}
	}
	return false;
}
void Media_StopRecordFilm_f(void);
/*funcs==null closes ALL decoders from this plugin*/
qboolean Media_UnregisterEncoder(struct plugin_s *plug, media_encoder_funcs_t *funcs)
{
	qboolean success = false;
	int i;

	for (i = 0; i < sizeof(pluginencodersfunc)/sizeof(pluginencodersfunc[0]); i++)
	{
		if (pluginencodersplugin[i])
		if (pluginencodersfunc[i] == funcs || (!funcs && pluginencodersplugin[i] == plug))
		{
			if (currentcapture_funcs == pluginencodersfunc[i])
				Media_StopRecordFilm_f();
			success = true;
			pluginencodersfunc[i] = NULL;
			pluginencodersplugin[i] = NULL;
			if (funcs)
				return success;
		}
	}
	return success;
}
 
//returns 0 if not capturing. 1 if capturing live. 2 if capturing a demo (where frame timings are forced).
int Media_Capturing (void)
{
	if (!currentcapture_funcs)
		return 0;
	return captureframeforce?2:1;
}

void Media_CapturePause_f (void)
{
	capturepaused = !capturepaused;
}

qboolean Media_PausedDemo (qboolean fortiming)
{
	//if fortiming is set, then timing might need to advance if we still need to parse the demo to get the first valid data out of it.

	if (capturepaused)
		return true;

	//capturedemo doesn't record any frames when the console is visible
	//but that's okay, as we don't load any demo frames either.
	if ((cls.demoplayback && Media_Capturing()))
		if (Key_Dest_Has(~kdm_game) || scr_con_current > 0 || (!fortiming&&!cl.validsequence))
			return true;

	return false;
}

static qboolean Media_ForceTimeInterval(void)
{
	return (cls.demoplayback && Media_Capturing() && captureframeinterval>0 && !Media_PausedDemo(false));
}

double Media_TweekCaptureFrameTime(double oldtime, double time)
{
	if (Media_ForceTimeInterval())
	{
		captureframeforce = true;
		//if we're forcing time intervals, then we use fixed time increments and generate a new video frame for every single frame.
		return capturelastvideotime;
	}
	return oldtime + time;
}

#ifdef VKQUAKE
static void Media_CapturedFrame (void *data, qintptr_t bytestride, size_t width, size_t height, enum uploadfmt fmt)
{
	if (currentcapture_funcs)
		currentcapture_funcs->capture_video(currentcapture_ctx, offscreen_captureframe, data, bytestride, width, height, fmt);
	offscreen_captureframe++;
}
#endif

void Media_RecordFrame (void)
{
	char *buffer;
	int bytestride, truewidth, trueheight;
	enum uploadfmt fmt;

	if (!currentcapture_funcs)
		return;

/*	if (*capturecutoff.string && captureframe * captureframeinterval > capturecutoff.value*60)
	{
		currentcapture_funcs->capture_end(currentcapture_ctx);
		currentcapture_ctx = currentcapture_funcs->capture_begin(Cmd_Argv(1), capturerate.value, vid.pixelwidth, vid.pixelheight, &sndkhz, &sndchannels, &sndbits);
		if (!currentcapture_ctx)
		{
			currentcapture_funcs = NULL;
			return;
		}
		captureframe = 0;
	}
*/
	if (Media_PausedDemo(false))
	{
		int y = vid.height -32-16;
		if (y < scr_con_current) y = scr_con_current;
		if (y > vid.height-8)
			y = vid.height-8;

#ifdef GLQUAKE
		if (capturingfbo && qrenderer == QR_OPENGL)
		{
			shader_t *pic;
			GLBE_FBO_Pop(captureoldfbo);
			vid.framebuffer = NULL;
			GL_Set2D(false);

			pic = R_RegisterShader("capturdemofeedback", SUF_NONE,
						"{\n"
							"program default2d\n"
							"{\n"
								"map $diffuse\n"
							"}\n"
						"}\n");
			pic->defaulttextures->base = capturetexture;
			//pulse green slightly, so its a bit more obvious
			R2D_ImageColours(1, 1+0.2*sin(realtime), 1, 1);
			R2D_Image(0, 0, vid.width, vid.height, 0, 1, 1, 0, pic);
			R2D_ImageColours(1, 1, 1, 1);
			Draw_FunString(0, 0, S_COLOR_RED"PAUSED");
			if (R2D_Flush)
				R2D_Flush();

			captureoldfbo = GLBE_FBO_Push(&capturefbo);
			vid.framebuffer = capturetexture;
			GL_Set2D(false);
		}
		else
#endif
			Draw_FunString((strlen(capturemessage.string)+1)*8, y, S_COLOR_RED "PAUSED");

		if (captureframeforce)
			capturelastvideotime += captureframeinterval;
		return;
	}

	//don't capture frames while we're loading.
	if (cl.sendprespawn || (cls.state < ca_active && COM_HasWork()))
	{
		capturelastvideotime += captureframeinterval;
		return;
	}

//overlay this on the screen, so it appears in the film
	if (*capturemessage.string)
	{
		int y = vid.height -32-16;
		if (y < scr_con_current) y = scr_con_current;
		if (y > vid.height-8)
			y = vid.height-8;
		Draw_FunString(0, y, capturemessage.string);
	}

	//time for annother frame?
	if (!captureframeforce)
	{
		if (capturelastvideotime > realtime+1)
			capturelastvideotime = realtime;	//urm, wrapped?..
		if (capturelastvideotime > realtime)
			goto skipframe;
	}
	
	if (cls.findtrack)
	{
		capturelastvideotime += captureframeinterval;
		return;	//skip until we're tracking the right player.
	}

	if (R2D_Flush)
		R2D_Flush();

#ifdef GLQUAKE_PBOS
	if (offscreen_format != TF_INVALID && qrenderer == QR_OPENGL)
	{
		int frame;
		//encode the frame if we're about to stomp on it
		while (offscreen_captureframe + countof(offscreen_queue) <= captureframe)
		{
			frame = offscreen_captureframe%countof(offscreen_queue);
			qglBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, offscreen_queue[frame].pbo_handle);
			buffer = qglMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY_ARB);
			if (buffer)
			{
				//FIXME: thread these (with audio too, to avoid races)
				currentcapture_funcs->capture_video(currentcapture_ctx, offscreen_captureframe, buffer, offscreen_queue[frame].stride, offscreen_queue[frame].width, offscreen_queue[frame].height, offscreen_queue[frame].format);
				qglUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
			}
			offscreen_captureframe++;
		}

		frame = captureframe%countof(offscreen_queue);
		//if we have no pbo yet, create one.
		if (!offscreen_queue[frame].pbo_handle || offscreen_queue[frame].width != vid.fbpwidth || offscreen_queue[frame].height != vid.fbpheight)
		{
			int imagesize = 0;
			if (offscreen_queue[frame].pbo_handle)
				qglDeleteBuffersARB(1, &offscreen_queue[frame].pbo_handle);
			offscreen_queue[frame].format = offscreen_format;
			offscreen_queue[frame].width = vid.fbpwidth;
			offscreen_queue[frame].height = vid.fbpheight;
			switch(offscreen_queue[frame].format)
			{
			case TF_BGR24:
			case TF_RGB24:
				imagesize = 3;
				break;
			case TF_BGRA32:
			case TF_RGBA32:
				imagesize = 4;
				break;
			default:
				break;
			}

			offscreen_queue[frame].stride = vid.fbpwidth*-imagesize;//gl is upside down

			imagesize *= offscreen_queue[frame].width * offscreen_queue[frame].height;

			qglGenBuffersARB(1, &offscreen_queue[frame].pbo_handle);
			qglBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, offscreen_queue[frame].pbo_handle);
			qglBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imagesize, NULL, GL_STREAM_READ_ARB);
		}

		//get the gpu to copy the texture into the pbo. the driver should pipeline this read until we actually map the pbo, hopefully avoiding stalls
		qglBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, offscreen_queue[frame].pbo_handle);
		switch(offscreen_queue[frame].format)
		{
		case TF_BGR24:
			qglReadPixels(0, 0, offscreen_queue[frame].width, offscreen_queue[frame].height, GL_BGR_EXT, GL_UNSIGNED_BYTE, 0);
			break;
		case TF_BGRA32:
			qglReadPixels(0, 0, offscreen_queue[frame].width, offscreen_queue[frame].height, GL_BGRA_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
			break;
		case TF_RGB24:
			qglReadPixels(0, 0, offscreen_queue[frame].width, offscreen_queue[frame].height, GL_RGB, GL_UNSIGNED_BYTE, 0);
			break;
		case TF_RGBA32:
			qglReadPixels(0, 0, offscreen_queue[frame].width, offscreen_queue[frame].height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
			break;
		default:
			break;
		}
		qglBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
	}
	else
#endif
#ifdef VKQUAKE
	if (qrenderer == QR_VULKAN)
		VKVID_QueueGetRGBData(Media_CapturedFrame);
	else
#endif
	{
		offscreen_captureframe = captureframe+1;
		//submit the current video frame. audio will be mixed to match.
		buffer = VID_GetRGBInfo(&bytestride, &truewidth, &trueheight, &fmt);
		if (buffer)
		{
			qbyte *firstrow = (bytestride<0)?buffer - bytestride*(trueheight-1):buffer;
			currentcapture_funcs->capture_video(currentcapture_ctx, captureframe, firstrow, bytestride, truewidth, trueheight, fmt);
			BZ_Free (buffer);
		}
		else
		{
			Con_DPrintf("Unable to grab video image\n");
			currentcapture_funcs->capture_video(currentcapture_ctx, captureframe, NULL, 0, 0, 0, TF_INVALID);
		}
	}
	captureframe++;
	capturelastvideotime += captureframeinterval;

	captureframeforce = false;

	//this is drawn to the screen and not the film
skipframe:
{
	int y = vid.height -32-16;
	if (y < scr_con_current) y = scr_con_current;
	if (y > vid.height-8)
		y = vid.height-8;

#ifdef GLQUAKE
	if (capturingfbo && qrenderer == QR_OPENGL)
	{
		shader_t *pic;
		GLBE_FBO_Pop(captureoldfbo);
		vid.framebuffer = NULL;
		GL_Set2D(false);

		pic = R_RegisterShader("capturdemofeedback", SUF_NONE,
					"{\n"
						"program default2d\n"
						"{\n"
							"map $diffuse\n"
						"}\n"
					"}\n");
		pic->defaulttextures->base = capturetexture;
		//pulse green slightly, so its a bit more obvious
		R2D_ImageColours(1, 1+0.2*sin(realtime), 1, 1);
		R2D_Image(0, 0, vid.width, vid.height, 0, 1, 1, 0, pic);
		R2D_ImageColours(1, 1, 1, 1);
		Draw_FunString(0, 0, va(S_COLOR_RED"RECORDING OFFSCREEN %g", capturelastvideotime));
		if (R2D_Flush)
			R2D_Flush();

		captureoldfbo = GLBE_FBO_Push(&capturefbo);
		vid.framebuffer = capturetexture;
		GL_Set2D(false);
	}
	else
#endif
		Draw_FunString((strlen(capturemessage.string)+1)*8, y, S_COLOR_RED"RECORDING");
}
}

static void *MSD_Lock (soundcardinfo_t *sc, unsigned int *sampidx)
{
	return sc->sn.buffer;
}
static void MSD_Unlock (soundcardinfo_t *sc, void *buffer)
{
}

static unsigned int MSD_GetDMAPos(soundcardinfo_t *sc)
{
	int		s;

	s = captureframe*(sc->sn.speed*captureframeinterval);


//	s >>= sc->sn.samplebytes - 1;
	s *= sc->sn.numchannels;
	return s;
}

static void MSD_Submit(soundcardinfo_t *sc, int start, int end)
{
	//Fixme: support outputting to wav
	//http://www.borg.com/~jglatt/tech/wave.htm


	int lastpos;
	int newpos;
	int framestosubmit;
	int offset;
	int bytesperframe;
	int minframes = 576;	//mp3 requires this (which we use for vfw)
	int maxframes = 576;

	newpos = sc->paintedtime;

	while(1)
	{
		lastpos = sc->snd_completed;
		framestosubmit = newpos - lastpos;
		if (framestosubmit < minframes)
			return;
		if (framestosubmit > maxframes)
			framestosubmit = maxframes;

		bytesperframe = sc->sn.numchannels*sc->sn.samplebytes;

		offset = (lastpos % (sc->sn.samples/sc->sn.numchannels));

		//we could just use a buffer size equal to the number of samples in each frame
		//but that isn't as robust when it comes to floating point imprecisions
		//namly: that it would loose a sample each frame with most framerates.

		if ((sc->snd_completed % (sc->sn.samples/sc->sn.numchannels)) < offset)
		{
			framestosubmit = ((sc->sn.samples/sc->sn.numchannels)) - offset;
			offset = 0;
		}
		currentcapture_funcs->capture_audio(currentcapture_ctx, sc->sn.buffer+offset*bytesperframe, framestosubmit*bytesperframe);
		sc->snd_completed += framestosubmit;
	}
}

static void MSD_Shutdown (soundcardinfo_t *sc)
{
	Z_Free(sc->sn.buffer);
	capture_fakesounddevice = NULL;
}

void Media_InitFakeSoundDevice (int speed, int channels, int samplebits)
{
	soundcardinfo_t *sc;

	if (capture_fakesounddevice)
		return;

	//when we're recording a demo, we'll be timedemoing it as it were.
	//this means that the actual sound devices and the fake device will be going at different rates
	//which really confuses any stream decoding, like music.
	//so just kill all actual sound devices.
	if (recordingdemo)
	{
		soundcardinfo_t *next;
		for (sc = sndcardinfo; sc; sc=next)
		{
			next = sc->next;
			sc->Shutdown(sc);
			Z_Free(sc);
			sndcardinfo = next;
		}
	}

	if (!snd_speed)
		snd_speed = speed;

	sc = Z_Malloc(sizeof(soundcardinfo_t));

	sc->seat = -1;
	sc->snd_sent = 0;
	sc->snd_completed = 0;

	sc->sn.samples = speed*0.5;
	sc->sn.speed = speed;
	switch(samplebits)
	{
	case 32:
		sc->sn.samplebytes = 4;
		sc->sn.sampleformat = QSF_F32;
		break;
	default:
	case 16:
		sc->sn.samplebytes = 2;
		sc->sn.sampleformat = QSF_S16;
		break;
	case 8:
		sc->sn.samplebytes = 1;
		sc->sn.sampleformat = QSF_U8;
		break;
	}
	sc->sn.samplepos = 0;
	sc->sn.numchannels = channels;
	sc->inactive_sound = true;

	sc->sn.samples -= sc->sn.samples%1152;	//truncate slightly to keep vfw happy.
	sc->samplequeue = -1;

	sc->sn.buffer = (unsigned char *) BZ_Malloc(sc->sn.samples*sc->sn.numchannels*sc->sn.samplebytes);

	Z_ReallocElements((void**)&sc->channel, &sc->max_chans, MAX_DYNAMIC_CHANNELS+NUM_AMBIENTS+NUM_MUSICS, sizeof(*sc->channel));

	sc->Lock		= MSD_Lock;
	sc->Unlock		= MSD_Unlock;
	sc->Submit		= MSD_Submit;
	sc->Shutdown	= MSD_Shutdown;
	sc->GetDMAPos	= MSD_GetDMAPos;

	sc->next = sndcardinfo;
	sndcardinfo = sc;

	capture_fakesounddevice = sc;

	S_DefaultSpeakerConfiguration(sc);
}

//stops capturing and destroys everything.
static void Media_FlushCapture(void)
{
#ifdef GLQUAKE_PBOS
	if (offscreen_format && qrenderer == QR_OPENGL)
	{
		int frame;
		qbyte *buffer;
		while (offscreen_captureframe < captureframe)
		{
			frame = offscreen_captureframe%countof(offscreen_queue);
			qglBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, offscreen_queue[frame].pbo_handle);
			buffer = qglMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY_ARB);
			if (buffer)
			{
				currentcapture_funcs->capture_video(currentcapture_ctx, offscreen_captureframe, buffer, offscreen_queue[frame].stride, offscreen_queue[frame].width, offscreen_queue[frame].height, offscreen_queue[frame].format);
				qglUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
			}
			offscreen_captureframe++;
		}

		for (frame = 0; frame < countof(offscreen_queue); frame++)
		{
			if (offscreen_queue[frame].pbo_handle)
				qglDeleteBuffersARB(1, &offscreen_queue[frame].pbo_handle);
			memset(&offscreen_queue[frame], 0, sizeof(offscreen_queue[frame]));
		}
	}
#endif
#if 0//def VKQUAKE
	if (pbo_format && qrenderer == QR_VULKAN)
	{
		int frame;
		while (offscreen_captureframe < captureframe)
		{
			frame = offscreen_captureframe%countof(offscreen_queue);
			qbyte *buffer;
			qglBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, offscreen_queue[frame].pbo_handle);
			buffer = qglMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY_ARB);
			if (buffer)
			{
				currentcapture_funcs->capture_video(currentcapture_ctx, buffer, offscreen_captureframe, offscreen_queue[frame].width, offscreen_queue[frame].height, offscreen_queue[frame].format);
				qglUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
			}
			offscreen_captureframe++;
		}

		for (frame = 0; frame < countof(offscreen_queue); frame++)
		{
			if (offscreen_queue[frame].pbo_handle)
				qglDeleteBuffersARB(1, &offscreen_queue[frame].pbo_handle);
			memset(&offscreen_queue[frame], 0, sizeof(offscreen_queue[frame]));
		}
	}
#endif

#ifdef GLQUAKE
	if (capturingfbo && qrenderer == QR_OPENGL)
	{
		GLBE_FBO_Pop(captureoldfbo);
		GLBE_FBO_Destroy(&capturefbo);
		vid.framebuffer = NULL;
	}
#endif
}

void Media_StopRecordFilm_f (void)
{
	Media_FlushCapture();
	capturingfbo = false;

	if (capture_fakesounddevice)
		S_ShutdownCard(capture_fakesounddevice);
	capture_fakesounddevice = NULL;

	if (recordingdemo)	//start up their regular audio devices again.
		S_DoRestart(false);

	recordingdemo=false;

	if (currentcapture_funcs)
		currentcapture_funcs->capture_end(currentcapture_ctx);
	currentcapture_ctx = NULL;
	currentcapture_funcs = NULL;

	Cvar_ForceCallback(&vid_conautoscale);
}
void Media_VideoRestarting(void)
{
	Media_FlushCapture();
}
void Media_VideoRestarted(void)
{
#ifdef GLQUAKE
	if (capturingfbo && qrenderer == QR_OPENGL && gl_config.ext_framebuffer_objects)
	{	//restore it how it was, if we can.
		int w = capturefbo.rb_size[0], h = capturefbo.rb_size[1];
		capturingfbo = true;
		capturetexture = R2D_RT_Configure("$democapture", w, h, TF_BGRA32, RT_IMAGEFLAGS);
		captureoldfbo = GLBE_FBO_Update(&capturefbo, FBO_RB_DEPTH|(Sh_StencilShadowsActive()?FBO_RB_STENCIL:0), &capturetexture, 1, r_nulltex, capturetexture->width, capturetexture->height, 0);
		vid.fbpwidth = capturetexture->width;
		vid.fbpheight = capturetexture->height;
		vid.framebuffer = capturetexture;
	}
	else
#endif
		capturingfbo = false;

	if (capturingfbo)
		Cvar_ForceCallback(&vid_conautoscale);
}
static void Media_RecordFilm (char *recordingname, qboolean demo)
{
	int sndkhz, sndchannels, sndbits;
	int i;

	Media_StopRecordFilm_f();

	if (capturerate.value<=0)
	{
		Con_Printf("Invalid capturerate\n");
		capturerate.value = 15;
	}

	captureframeinterval = 1/capturerate.value;
	if (captureframeinterval < 0.001)
		captureframeinterval = 0.001;	//no more than 1000 images per second.
	capturelastvideotime = realtime = 0;

	Con_ClearNotify();

	captureframe = offscreen_captureframe = 0;
	for (i = 0; i < sizeof(pluginencodersfunc)/sizeof(pluginencodersfunc[0]); i++)
	{
		if (pluginencodersfunc[i])
			if (!strcmp(pluginencodersfunc[i]->drivername, capturedriver.string))
				currentcapture_funcs = pluginencodersfunc[i];
	}
	if (!currentcapture_funcs)
	{
		for (i = 0; i < countof(pluginencodersfunc); i++)
		{
			if (pluginencodersfunc[i])
			{
				currentcapture_funcs = pluginencodersfunc[i];
				break;
			}
		}
	}
	if (capturesound.ival)
	{
		sndkhz = snd_speed?snd_speed:48000;
		sndchannels = capturesoundchannels.ival;
		sndbits = capturesoundbits.ival;
	}
	else
	{
		sndkhz = 0;
		sndchannels = 0;
		sndbits = 0;
	}

	vid.fbpwidth = vid.pixelwidth;
	vid.fbpheight = vid.pixelheight;
	if (demo && capturewidth.ival && captureheight.ival)
	{
#ifdef GLQUAKE
		if (qrenderer == QR_OPENGL && gl_config.ext_framebuffer_objects)
		{
			capturingfbo = true;
			capturetexture = R2D_RT_Configure("$democapture", capturewidth.ival, captureheight.ival, TF_BGRA32, RT_IMAGEFLAGS);
			captureoldfbo = GLBE_FBO_Update(&capturefbo, FBO_RB_DEPTH|(Sh_StencilShadowsActive()?FBO_RB_STENCIL:0), &capturetexture, 1, r_nulltex, capturewidth.ival, captureheight.ival, 0);
			vid.fbpwidth = capturetexture->width;
			vid.fbpheight = capturetexture->height;
			vid.framebuffer = capturetexture;
		}
#endif
	}

	offscreen_format = TF_INVALID;
#ifdef GLQUAKE_PBOS
	if (qrenderer == QR_OPENGL && !gl_config.gles && gl_config.glversion >= 2.1)
	{	//both tgas and vfw favour bgr24, so lets get the gl drivers to suffer instead of us, where possible.
		if (vid.fbpwidth & 3)
			offscreen_format = TF_BGRA32;	//don't bother changing pack alignment, just use something that is guarenteed to not need anything.
		else
			offscreen_format = TF_BGR24;
	}
#endif
#ifdef VKQUAKE
//	if (qrenderer == QR_VULKAN)
//		offscreen_format = TF_BGRA32;	//use the native format, the driver won't do byteswapping for us.
#endif

	recordingdemo = demo;
	
	if (!currentcapture_funcs->capture_begin)
		currentcapture_ctx = NULL;
	else
	{
		char fname[MAX_QPATH];
		char ext[8];
		COM_FileExtension(recordingname, ext, sizeof(ext));
		if (!strcmp(ext, "dem") || !strcmp(ext, "qwd") || !strcmp(ext, "mvd") || !strcmp(ext, "dm2") || !strcmp(ext, "gz") || !strcmp(ext, "xz") || !*ext)
		{	//extensions are evil, but whatever.
			//make sure there is actually an extension there, and don't break if they try overwriting a known demo format...
			COM_StripExtension(recordingname, fname, sizeof(fname));
			if (currentcapture_funcs->defaultextension)
				Q_strncatz(fname, currentcapture_funcs->defaultextension, sizeof(fname));
			recordingname = fname;
		}

		currentcapture_ctx = currentcapture_funcs->capture_begin(recordingname, capturerate.value, vid.fbpwidth, vid.fbpheight, &sndkhz, &sndchannels, &sndbits);
	}
	if (!currentcapture_ctx)
	{
		recordingdemo = false;
		currentcapture_funcs = NULL;
		Con_Printf("Unable to initialise capture driver\n");
		Media_StopRecordFilm_f();
	}
	else if (sndkhz)
		Media_InitFakeSoundDevice(sndkhz, sndchannels, sndbits);

	Cvar_ForceCallback(&vid_conautoscale);
}
static void Media_RecordFilm_f (void)
{
	if (Cmd_Argc() != 2)
	{
		int i;
		Con_Printf("capture <filename>\nRecords video output in an avi file.\nUse capturerate and capturecodec to configure.\n\n");
		for (i = 0; i < countof(pluginencodersfunc); i++)
		{
			if (pluginencodersfunc[i])
				Con_Printf("%s%s^7: %s\n", !strcmp(pluginencodersfunc[i]->drivername, capturedriver.string)?"^2":"^3", pluginencodersfunc[i]->drivername, pluginencodersfunc[i]->description);
		}
		Con_Printf("\n");

		Con_Printf("Current capture settings:\n");
		Con_Printf(" ^[/capturedriver %s^]\n", capturedriver.string);
		Con_Printf(" ^[/capturecodec %s^]\n", capturecodec.string);
		Con_Printf(" ^[/capturedemowidth %s^]\n", capturewidth.string);
		Con_Printf(" ^[/capturedemoheight %s^]\n", captureheight.string);
		Con_Printf(" ^[/capturerate %s^]\n", capturerate.string);
		Con_Printf(" ^[/capturesound %s^]\n", capturesound.string);
		if (capturesound.value)
		{
			Con_Printf(" ^[/capturesoundchannels %s^]\n", capturesoundchannels.string);
			Con_Printf(" ^[/capturesoundbits %s^]\n", capturesoundbits.string);
		}
		return;
	}
	if (Cmd_IsInsecure())	//err... don't think so sonny.
		return;

	Media_RecordFilm(Cmd_Argv(1), false);
}
void Media_CaptureDemoEnd(void)
{
	if (recordingdemo)
		Media_StopRecordFilm_f();
}
void CL_PlayDemo(char *demoname, qboolean usesystempath);
void Media_RecordDemo_f(void)
{
	char *demoname = Cmd_Argv(1);
	char *videoname = Cmd_Argv(2);

	if (Cmd_FromGamecode())
		return;

	if (Cmd_Argc()<=1)
	{
		Con_Printf(	"capturedemo demoname outputname\n"
					"captures a demo to video frames using offline rendering for smoother results\n"
					"see also: apropos capture\n");
		return;
	}

	if (!Renderer_Started() && !isDedicated)
	{
		Cbuf_AddText(va("wait;%s %s\n", Cmd_Argv(0), Cmd_Args()), Cmd_ExecLevel);
		return;
	}

	if (Cmd_Argc()<=2)
		videoname = demoname;

	CL_Stopdemo_f();	//capturing failed for some reason

	CL_PlayDemo(demoname, false);
	if (!cls.demoplayback)
	{
		Con_Printf("unable to play demo, not capturing\n");
		return;
	}
	//FIXME: make sure it loaded okay
	Media_RecordFilm(videoname, true);
	scr_con_current=0;
	Key_Dest_Remove(kdm_console|kdm_emenu);

#ifdef MENU_DAT
	if (Key_Dest_Has(kdm_gmenu))
		MP_Toggle(0);
#endif

	if (!currentcapture_funcs)
		CL_Stopdemo_f();	//capturing failed for some reason
}
#else

void Media_CaptureDemoEnd(void) {}
qboolean Media_PausedDemo(qboolean fortiming) {return false;}
double Media_TweekCaptureFrameTime(double oldtime, double time) { return oldtime+time ; }
void Media_RecordFrame (void) {}
void Media_VideoRestarting(void) {}
void Media_VideoRestarted(void) {}

#endif





#ifdef HAVE_SPEECHTOTEXT
typedef struct ISpNotifySink ISpNotifySink;
typedef void *ISpNotifyCallback;
typedef void __stdcall SPNOTIFYCALLBACK(WPARAM wParam, LPARAM lParam);
typedef struct SPEVENT
{
    WORD        eEventId : 16;
    WORD  elParamType : 16;
    ULONG       ulStreamNum;
    ULONGLONG   ullAudioStreamOffset;
    WPARAM      wParam;
    LPARAM      lParam;
} SPEVENT;

#define SPEVENTSOURCEINFO void
#define ISpObjectToken void
#define ISpStreamFormat void
#define SPVOICESTATUS void
#define SPVPRIORITY int
#define SPEVENTENUM int

typedef struct ISpVoice ISpVoice;
typedef struct ISpVoiceVtbl
{
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
        ISpVoice * This,
        /* [in] */ REFIID riid,
        /* [iid_is][out] */ void **ppvObject);

    ULONG ( STDMETHODCALLTYPE *AddRef )(
        ISpVoice * This);

    ULONG ( STDMETHODCALLTYPE *Release )(
        ISpVoice * This);

    HRESULT ( STDMETHODCALLTYPE *SetNotifySink )(
        ISpVoice * This,
        /* [in] */ ISpNotifySink *pNotifySink);

    /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWindowMessage )(
        ISpVoice * This,
        /* [in] */ HWND hWnd,
        /* [in] */ UINT Msg,
        /* [in] */ WPARAM wParam,
        /* [in] */ LPARAM lParam);

    /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackFunction )(
        ISpVoice * This,
        /* [in] */ SPNOTIFYCALLBACK *pfnCallback,
        /* [in] */ WPARAM wParam,
        /* [in] */ LPARAM lParam);

    /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackInterface )(
        ISpVoice * This,
        /* [in] */ ISpNotifyCallback *pSpCallback,
        /* [in] */ WPARAM wParam,
        /* [in] */ LPARAM lParam);

    /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWin32Event )(
        ISpVoice * This);

    /* [local] */ HRESULT ( STDMETHODCALLTYPE *WaitForNotifyEvent )(
        ISpVoice * This,
        /* [in] */ DWORD dwMilliseconds);

    /* [local] */ HANDLE ( STDMETHODCALLTYPE *GetNotifyEventHandle )(
        ISpVoice * This);

    HRESULT ( STDMETHODCALLTYPE *SetInterest )(
        ISpVoice * This,
        /* [in] */ ULONGLONG ullEventInterest,
        /* [in] */ ULONGLONG ullQueuedInterest);

    HRESULT ( STDMETHODCALLTYPE *GetEvents )(
        ISpVoice * This,
        /* [in] */ ULONG ulCount,
        /* [size_is][out] */ SPEVENT *pEventArray,
        /* [out] */ ULONG *pulFetched);

    HRESULT ( STDMETHODCALLTYPE *GetInfo )(
        ISpVoice * This,
        /* [out] */ SPEVENTSOURCEINFO *pInfo);

    HRESULT ( STDMETHODCALLTYPE *SetOutput )(
        ISpVoice * This,
        /* [in] */ IUnknown *pUnkOutput,
        /* [in] */ BOOL fAllowFormatChanges);

    HRESULT ( STDMETHODCALLTYPE *GetOutputObjectToken )(
        ISpVoice * This,
        /* [out] */ ISpObjectToken **ppObjectToken);

    HRESULT ( STDMETHODCALLTYPE *GetOutputStream )(
        ISpVoice * This,
        /* [out] */ ISpStreamFormat **ppStream);

    HRESULT ( STDMETHODCALLTYPE *Pause )(
        ISpVoice * This);

    HRESULT ( STDMETHODCALLTYPE *Resume )(
        ISpVoice * This);

    HRESULT ( STDMETHODCALLTYPE *SetVoice )(
        ISpVoice * This,
        /* [in] */ ISpObjectToken *pToken);

    HRESULT ( STDMETHODCALLTYPE *GetVoice )(
        ISpVoice * This,
        /* [out] */ ISpObjectToken **ppToken);

    HRESULT ( STDMETHODCALLTYPE *Speak )(
        ISpVoice * This,
        /* [string][in] */ const WCHAR *pwcs,
        /* [in] */ DWORD dwFlags,
        /* [out] */ ULONG *pulStreamNumber);

    HRESULT ( STDMETHODCALLTYPE *SpeakStream )(
        ISpVoice * This,
        /* [in] */ IStream *pStream,
        /* [in] */ DWORD dwFlags,
        /* [out] */ ULONG *pulStreamNumber);

    HRESULT ( STDMETHODCALLTYPE *GetStatus )(
        ISpVoice * This,
        /* [out] */ SPVOICESTATUS *pStatus,
        /* [string][out] */ WCHAR **ppszLastBookmark);

    HRESULT ( STDMETHODCALLTYPE *Skip )(
        ISpVoice * This,
        /* [string][in] */ WCHAR *pItemType,
        /* [in] */ long lNumItems,
        /* [out] */ ULONG *pulNumSkipped);

    HRESULT ( STDMETHODCALLTYPE *SetPriority )(
        ISpVoice * This,
        /* [in] */ SPVPRIORITY ePriority);

    HRESULT ( STDMETHODCALLTYPE *GetPriority )(
        ISpVoice * This,
        /* [out] */ SPVPRIORITY *pePriority);

    HRESULT ( STDMETHODCALLTYPE *SetAlertBoundary )(
        ISpVoice * This,
        /* [in] */ SPEVENTENUM eBoundary);

    HRESULT ( STDMETHODCALLTYPE *GetAlertBoundary )(
        ISpVoice * This,
        /* [out] */ SPEVENTENUM *peBoundary);

    HRESULT ( STDMETHODCALLTYPE *SetRate )(
        ISpVoice * This,
        /* [in] */ long RateAdjust);

    HRESULT ( STDMETHODCALLTYPE *GetRate )(
        ISpVoice * This,
        /* [out] */ long *pRateAdjust);

    HRESULT ( STDMETHODCALLTYPE *SetVolume )(
        ISpVoice * This,
        /* [in] */ USHORT usVolume);

    HRESULT ( STDMETHODCALLTYPE *GetVolume )(
        ISpVoice * This,
        /* [out] */ USHORT *pusVolume);

    HRESULT ( STDMETHODCALLTYPE *WaitUntilDone )(
        ISpVoice * This,
        /* [in] */ ULONG msTimeout);

    HRESULT ( STDMETHODCALLTYPE *SetSyncSpeakTimeout )(
        ISpVoice * This,
        /* [in] */ ULONG msTimeout);

    HRESULT ( STDMETHODCALLTYPE *GetSyncSpeakTimeout )(
        ISpVoice * This,
        /* [out] */ ULONG *pmsTimeout);

    /* [local] */ HANDLE ( STDMETHODCALLTYPE *SpeakCompleteEvent )(
        ISpVoice * This);

    /* [local] */ HRESULT ( STDMETHODCALLTYPE *IsUISupported )(
        ISpVoice * This,
        /* [in] */ const WCHAR *pszTypeOfUI,
        /* [in] */ void *pvExtraData,
        /* [in] */ ULONG cbExtraData,
        /* [out] */ BOOL *pfSupported);

    /* [local] */ HRESULT ( STDMETHODCALLTYPE *DisplayUI )(
        ISpVoice * This,
        /* [in] */ HWND hwndParent,
        /* [in] */ const WCHAR *pszTitle,
        /* [in] */ const WCHAR *pszTypeOfUI,
        /* [in] */ void *pvExtraData,
        /* [in] */ ULONG cbExtraData);

    END_INTERFACE
} ISpVoiceVtbl;

struct ISpVoice
{
    struct ISpVoiceVtbl *lpVtbl;
};
void TTS_SayUnicodeString(wchar_t *stringtosay)
{
	static CLSID CLSID_SpVoice = {0x96749377, 0x3391, 0x11D2,
								{0x9E,0xE3,0x00,0xC0,0x4F,0x79,0x73,0x96}};
	static GUID IID_ISpVoice = {0x6C44DF74,0x72B9,0x4992,
								{0xA1,0xEC,0xEF,0x99,0x6E,0x04,0x22,0xD4}};
	static ISpVoice *sp = NULL;

	if (!sp)
		CoCreateInstance(
				&CLSID_SpVoice,
				NULL,
				CLSCTX_SERVER,
				&IID_ISpVoice,
				(void*)&sp);

	if (sp)
	{
		sp->lpVtbl->Speak(sp, stringtosay, 1, NULL);
	}
}
void TTS_SayAsciiString(char *stringtosay)
{
	wchar_t bigbuffer[8192];
	mbstowcs(bigbuffer, stringtosay, sizeof(bigbuffer)/sizeof(bigbuffer[0]) - 1);
	bigbuffer[sizeof(bigbuffer)/sizeof(bigbuffer[0]) - 1] = 0;
	TTS_SayUnicodeString(bigbuffer);
}

cvar_t tts_mode = CVARD("tts_mode", "1", "Text to speech\n0: off\n1: Read only chat messages with a leading 'tts ' prefix.\n2: Read all chat messages\n3: Read every single console print.");
void TTS_SayChatString(char **stringtosay)
{
	if (!strncmp(*stringtosay, "tts ", 4))
	{
		*stringtosay += 4;
		if (tts_mode.ival != 1 && tts_mode.ival != 2)
			return;
	}
	else
	{
		if (tts_mode.ival != 2)
			return;
	}

	TTS_SayAsciiString(*stringtosay);
}
void TTS_SayConString(conchar_t *stringtosay)
{
	wchar_t bigbuffer[8192];
	int i;

	if (tts_mode.ival < 3)
		return;
	
	for (i = 0; i < 8192-1 && *stringtosay; i++, stringtosay++)
	{
		if ((*stringtosay & 0xff00) == 0xe000)
			bigbuffer[i] = *stringtosay & 0x7f;
		else
			bigbuffer[i] = *stringtosay & CON_CHARMASK;
	}
	bigbuffer[i] = 0;
	if (i)
		TTS_SayUnicodeString(bigbuffer);
}
void TTS_Say_f(void)
{
	TTS_SayAsciiString(Cmd_Args());
}

#define ISpRecognizer void
#define SPPHRASE void
#define SPSERIALIZEDPHRASE void
#define SPSTATEHANDLE void*
#define SPGRAMMARWORDTYPE int
#define SPPROPERTYINFO void
#define SPLOADOPTIONS void*
#define SPBINARYGRAMMAR void*
#define SPRULESTATE int
#define SPTEXTSELECTIONINFO void
#define SPWORDPRONOUNCEABLE void
#define SPGRAMMARSTATE int
typedef struct ISpRecoResult ISpRecoResult;
typedef struct ISpRecoContext ISpRecoContext;
typedef struct ISpRecoGrammar ISpRecoGrammar;

typedef struct ISpRecoContextVtbl
{
	HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
		ISpRecoContext * This,
		/* [in] */ REFIID riid,
		/* [iid_is][out] */ void **ppvObject);

	ULONG ( STDMETHODCALLTYPE *AddRef )( 
		ISpRecoContext * This);

	ULONG ( STDMETHODCALLTYPE *Release )( 
		ISpRecoContext * This);

    HRESULT ( STDMETHODCALLTYPE *SetNotifySink )( 
        ISpRecoContext * This,
        /* [in] */ ISpNotifySink *pNotifySink);
    
    /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWindowMessage )( 
        ISpRecoContext * This,
        /* [in] */ HWND hWnd,
        /* [in] */ UINT Msg,
        /* [in] */ WPARAM wParam,
        /* [in] */ LPARAM lParam);
    
    /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackFunction )( 
        ISpRecoContext * This,
        /* [in] */ SPNOTIFYCALLBACK *pfnCallback,
        /* [in] */ WPARAM wParam,
        /* [in] */ LPARAM lParam);
    
    /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyCallbackInterface )( 
        ISpRecoContext * This,
        /* [in] */ ISpNotifyCallback *pSpCallback,
        /* [in] */ WPARAM wParam,
        /* [in] */ LPARAM lParam);
    
    /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetNotifyWin32Event )( 
        ISpRecoContext * This);
    
    /* [local] */ HRESULT ( STDMETHODCALLTYPE *WaitForNotifyEvent )( 
        ISpRecoContext * This,
        /* [in] */ DWORD dwMilliseconds);
    
    /* [local] */ HANDLE ( STDMETHODCALLTYPE *GetNotifyEventHandle )( 
        ISpRecoContext * This);
    
    HRESULT ( STDMETHODCALLTYPE *SetInterest )( 
        ISpRecoContext * This,
        /* [in] */ ULONGLONG ullEventInterest,
        /* [in] */ ULONGLONG ullQueuedInterest);
    
    HRESULT ( STDMETHODCALLTYPE *GetEvents )( 
        ISpRecoContext * This,
        /* [in] */ ULONG ulCount,
        /* [size_is][out] */ SPEVENT *pEventArray,
        /* [out] */ ULONG *pulFetched);

    HRESULT ( STDMETHODCALLTYPE *GetInfo )( 
        ISpRecoContext * This,
        /* [out] */ SPEVENTSOURCEINFO *pInfo);
    
    HRESULT ( STDMETHODCALLTYPE *GetRecognizer )( 
        ISpRecoContext * This,
        /* [out] */ ISpRecognizer **ppRecognizer);
    
    HRESULT ( STDMETHODCALLTYPE *CreateGrammar )( 
        ISpRecoContext * This,
        /* [in] */ ULONGLONG ullGrammarId,
        /* [out] */ ISpRecoGrammar **ppGrammar);
} ISpRecoContextVtbl;
struct ISpRecoContext
{
    struct ISpRecoContextVtbl *lpVtbl;
};

typedef struct ISpRecoResultVtbl
{
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        ISpRecoResult * This,
        /* [in] */ REFIID riid,
        /* [iid_is][out] */ void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        ISpRecoResult * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        ISpRecoResult * This);
    
    HRESULT ( STDMETHODCALLTYPE *GetPhrase )( 
        ISpRecoResult * This,
        /* [out] */ SPPHRASE **ppCoMemPhrase);
    
    HRESULT ( STDMETHODCALLTYPE *GetSerializedPhrase )( 
        ISpRecoResult * This,
        /* [out] */ SPSERIALIZEDPHRASE **ppCoMemPhrase);
    
    HRESULT ( STDMETHODCALLTYPE *GetText )( 
        ISpRecoResult * This,
        /* [in] */ ULONG ulStart,
        /* [in] */ ULONG ulCount,
        /* [in] */ BOOL fUseTextReplacements,
        /* [out] */ WCHAR **ppszCoMemText,
        /* [out] */ BYTE *pbDisplayAttributes);
    
    HRESULT ( STDMETHODCALLTYPE *Discard )( 
        ISpRecoResult * This,
        /* [in] */ DWORD dwValueTypes);
#if 0
    HRESULT ( STDMETHODCALLTYPE *GetResultTimes )( 
        ISpRecoResult * This,
        /* [out] */ SPRECORESULTTIMES *pTimes);
    
    HRESULT ( STDMETHODCALLTYPE *GetAlternates )( 
        ISpRecoResult * This,
        /* [in] */ ULONG ulStartElement,
        /* [in] */ ULONG cElements,
        /* [in] */ ULONG ulRequestCount,
        /* [out] */ ISpPhraseAlt **ppPhrases,
        /* [out] */ ULONG *pcPhrasesReturned);
    
    HRESULT ( STDMETHODCALLTYPE *GetAudio )( 
        ISpRecoResult * This,
        /* [in] */ ULONG ulStartElement,
        /* [in] */ ULONG cElements,
        /* [out] */ ISpStreamFormat **ppStream);
    
    HRESULT ( STDMETHODCALLTYPE *SpeakAudio )( 
        ISpRecoResult * This,
        /* [in] */ ULONG ulStartElement,
        /* [in] */ ULONG cElements,
        /* [in] */ DWORD dwFlags,
        /* [out] */ ULONG *pulStreamNumber);
    
    HRESULT ( STDMETHODCALLTYPE *Serialize )( 
        ISpRecoResult * This,
        /* [out] */ SPSERIALIZEDRESULT **ppCoMemSerializedResult);
    
    HRESULT ( STDMETHODCALLTYPE *ScaleAudio )( 
        ISpRecoResult * This,
        /* [in] */ const GUID *pAudioFormatId,
        /* [in] */ const WAVEFORMATEX *pWaveFormatEx);
    
    HRESULT ( STDMETHODCALLTYPE *GetRecoContext )( 
        ISpRecoResult * This,
        /* [out] */ ISpRecoContext **ppRecoContext);
    
#endif
} ISpRecoResultVtbl;
struct ISpRecoResult
{
    struct ISpRecoResultVtbl *lpVtbl;
};

typedef struct ISpRecoGrammarVtbl
{
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        ISpRecoGrammar * This,
        /* [in] */ REFIID riid,
        /* [iid_is][out] */ void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        ISpRecoGrammar * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        ISpRecoGrammar * This);
    
    HRESULT ( STDMETHODCALLTYPE *ResetGrammar )( 
        ISpRecoGrammar * This,
        /* [in] */ WORD NewLanguage);
    
    HRESULT ( STDMETHODCALLTYPE *GetRule )( 
        ISpRecoGrammar * This,
        /* [in] */ const WCHAR *pszRuleName,
        /* [in] */ DWORD dwRuleId,
        /* [in] */ DWORD dwAttributes,
        /* [in] */ BOOL fCreateIfNotExist,
        /* [out] */ SPSTATEHANDLE *phInitialState);
    
    HRESULT ( STDMETHODCALLTYPE *ClearRule )( 
        ISpRecoGrammar * This,
        SPSTATEHANDLE hState);
    
    HRESULT ( STDMETHODCALLTYPE *CreateNewState )( 
        ISpRecoGrammar * This,
        SPSTATEHANDLE hState,
        SPSTATEHANDLE *phState);
    
    HRESULT ( STDMETHODCALLTYPE *AddWordTransition )( 
        ISpRecoGrammar * This,
        SPSTATEHANDLE hFromState,
        SPSTATEHANDLE hToState,
        const WCHAR *psz,
        const WCHAR *pszSeparators,
        SPGRAMMARWORDTYPE eWordType,
        float Weight,
        const SPPROPERTYINFO *pPropInfo);
    
    HRESULT ( STDMETHODCALLTYPE *AddRuleTransition )( 
        ISpRecoGrammar * This,
        SPSTATEHANDLE hFromState,
        SPSTATEHANDLE hToState,
        SPSTATEHANDLE hRule,
        float Weight,
        const SPPROPERTYINFO *pPropInfo);
    
    HRESULT ( STDMETHODCALLTYPE *AddResource )( 
        ISpRecoGrammar * This,
        /* [in] */ SPSTATEHANDLE hRuleState,
        /* [in] */ const WCHAR *pszResourceName,
        /* [in] */ const WCHAR *pszResourceValue);
    
    HRESULT ( STDMETHODCALLTYPE *Commit )( 
        ISpRecoGrammar * This,
        DWORD dwReserved);
    
    HRESULT ( STDMETHODCALLTYPE *GetGrammarId )( 
        ISpRecoGrammar * This,
        /* [out] */ ULONGLONG *pullGrammarId);
    
    HRESULT ( STDMETHODCALLTYPE *GetRecoContext )( 
        ISpRecoGrammar * This,
        /* [out] */ ISpRecoContext **ppRecoCtxt);
    
    HRESULT ( STDMETHODCALLTYPE *LoadCmdFromFile )( 
        ISpRecoGrammar * This,
        /* [string][in] */ const WCHAR *pszFileName,
        /* [in] */ SPLOADOPTIONS Options);
    
    HRESULT ( STDMETHODCALLTYPE *LoadCmdFromObject )( 
        ISpRecoGrammar * This,
        /* [in] */ REFCLSID rcid,
        /* [string][in] */ const WCHAR *pszGrammarName,
        /* [in] */ SPLOADOPTIONS Options);
    
    HRESULT ( STDMETHODCALLTYPE *LoadCmdFromResource )( 
        ISpRecoGrammar * This,
        /* [in] */ HMODULE hModule,
        /* [string][in] */ const WCHAR *pszResourceName,
        /* [string][in] */ const WCHAR *pszResourceType,
        /* [in] */ WORD wLanguage,
        /* [in] */ SPLOADOPTIONS Options);
    
    HRESULT ( STDMETHODCALLTYPE *LoadCmdFromMemory )( 
        ISpRecoGrammar * This,
        /* [in] */ const SPBINARYGRAMMAR *pGrammar,
        /* [in] */ SPLOADOPTIONS Options);
    
    HRESULT ( STDMETHODCALLTYPE *LoadCmdFromProprietaryGrammar )( 
        ISpRecoGrammar * This,
        /* [in] */ REFGUID rguidParam,
        /* [string][in] */ const WCHAR *pszStringParam,
        /* [in] */ const void *pvDataPrarm,
        /* [in] */ ULONG cbDataSize,
        /* [in] */ SPLOADOPTIONS Options);
    
    HRESULT ( STDMETHODCALLTYPE *SetRuleState )( 
        ISpRecoGrammar * This,
        /* [string][in] */ const WCHAR *pszName,
        void *pReserved,
        /* [in] */ SPRULESTATE NewState);
    
    HRESULT ( STDMETHODCALLTYPE *SetRuleIdState )( 
        ISpRecoGrammar * This,
        /* [in] */ ULONG ulRuleId,
        /* [in] */ SPRULESTATE NewState);
    
    HRESULT ( STDMETHODCALLTYPE *LoadDictation )( 
        ISpRecoGrammar * This,
        /* [string][in] */ const WCHAR *pszTopicName,
        /* [in] */ SPLOADOPTIONS Options);
    
    HRESULT ( STDMETHODCALLTYPE *UnloadDictation )( 
        ISpRecoGrammar * This);
    
    HRESULT ( STDMETHODCALLTYPE *SetDictationState )( 
        ISpRecoGrammar * This,
        /* [in] */ SPRULESTATE NewState);
    
    HRESULT ( STDMETHODCALLTYPE *SetWordSequenceData )( 
        ISpRecoGrammar * This,
        /* [in] */ const WCHAR *pText,
        /* [in] */ ULONG cchText,
        /* [in] */ const SPTEXTSELECTIONINFO *pInfo);
    
    HRESULT ( STDMETHODCALLTYPE *SetTextSelection )( 
        ISpRecoGrammar * This,
        /* [in] */ const SPTEXTSELECTIONINFO *pInfo);
    
    HRESULT ( STDMETHODCALLTYPE *IsPronounceable )( 
        ISpRecoGrammar * This,
        /* [string][in] */ const WCHAR *pszWord,
        /* [out] */ SPWORDPRONOUNCEABLE *pWordPronounceable);
    
    HRESULT ( STDMETHODCALLTYPE *SetGrammarState )( 
        ISpRecoGrammar * This,
        /* [in] */ SPGRAMMARSTATE eGrammarState);
    
    HRESULT ( STDMETHODCALLTYPE *SaveCmd )( 
        ISpRecoGrammar * This,
        /* [in] */ IStream *pStream,
        /* [optional][out] */ WCHAR **ppszCoMemErrorText);
    
    HRESULT ( STDMETHODCALLTYPE *GetGrammarState )( 
        ISpRecoGrammar * This,
        /* [out] */ SPGRAMMARSTATE *peGrammarState);
} ISpRecoGrammarVtbl;
struct ISpRecoGrammar
{
	struct ISpRecoGrammarVtbl *lpVtbl;
};

static ISpRecoContext *stt_recctx = NULL;
static ISpRecoGrammar *stt_gram = NULL;
void STT_Event(void)
{
	WCHAR *wstring, *i;
	struct SPEVENT ev;
	ISpRecoResult *rr;
	HRESULT hr;
	char asc[2048], *o;
	int l;
	unsigned short c;
	char *nib = "0123456789abcdef";
	if (!stt_gram)
		return;

	while (SUCCEEDED(hr = stt_recctx->lpVtbl->GetEvents(stt_recctx, 1, &ev, NULL)) && hr != S_FALSE)
	{
		rr = (ISpRecoResult*)ev.lParam;
		rr->lpVtbl->GetText(rr, -1, -1, TRUE, &wstring, NULL);
		for (l = sizeof(asc)-1, o = asc, i = wstring; l > 0 && *i; )
		{
			c = *i++;
			if (c == '\n' || c == ';')
			{
			}
			else if (c < 128)
			{
				*o++ = c;
				l--;
			}
			else if (l > 6)
			{
				*o++ = '^';
				*o++ = 'U';
				*o++ = nib[(c>>12)&0xf];
				*o++ = nib[(c>>8)&0xf];
				*o++ = nib[(c>>4)&0xf];
				*o++ = nib[(c>>0)&0xf];
			}
			else
				break;
		}
		*o = 0;
		CoTaskMemFree(wstring);
		Cbuf_AddText("say tts ", RESTRICT_LOCAL);
		Cbuf_AddText(asc, RESTRICT_LOCAL);
		Cbuf_AddText("\n", RESTRICT_LOCAL);
		rr->lpVtbl->Release(rr);
	}
}
void STT_Init_f(void)
{
	static CLSID CLSID_SpSharedRecoContext	=	{0x47206204, 0x5ECA, 0x11D2, {0x96, 0x0F, 0x00, 0xC0, 0x4F, 0x8E, 0xE6, 0x28}};
	static CLSID IID_SpRecoContext			=	{0xF740A62F, 0x7C15, 0x489E, {0x82, 0x34, 0x94, 0x0A, 0x33, 0xD9, 0x27, 0x2D}};

	if (stt_gram)
	{
		stt_gram->lpVtbl->Release(stt_gram);
		stt_recctx->lpVtbl->Release(stt_recctx);
		stt_gram = NULL;
		stt_recctx = NULL;
		Con_Printf("Speech-to-text disabled\n");
		return;
	}

	if (SUCCEEDED(CoCreateInstance(&CLSID_SpSharedRecoContext, NULL, CLSCTX_SERVER, &IID_SpRecoContext, (void*)&stt_recctx)))
	{
		ULONGLONG ev = (((ULONGLONG)1) << 38) | (((ULONGLONG)1) << 30) | (((ULONGLONG)1) << 33);
		if (SUCCEEDED(stt_recctx->lpVtbl->SetNotifyWindowMessage(stt_recctx, mainwindow, WM_USER_SPEECHTOTEXT, 0, 0)))
		if (SUCCEEDED(stt_recctx->lpVtbl->SetInterest(stt_recctx, ev, ev)))
		if (SUCCEEDED(stt_recctx->lpVtbl->CreateGrammar(stt_recctx, 0, &stt_gram)))
		{
			if (SUCCEEDED(stt_gram->lpVtbl->LoadDictation(stt_gram, NULL, 0)))
			if (SUCCEEDED(stt_gram->lpVtbl->SetDictationState(stt_gram, 1)))
			{
				//success!
				Con_Printf("Speech-to-text active\n");
				return;
			}
			stt_gram->lpVtbl->Release(stt_gram);
		}
		stt_recctx->lpVtbl->Release(stt_recctx);
	}
	stt_gram = NULL;
	stt_recctx = NULL;

	Con_Printf("Speech-to-text unavailable\n");
}
#endif






#ifdef AVAIL_MP3_ACM
typedef struct
{
	HACMSTREAM acm;

	unsigned int dstbuffer; /*in frames*/
	unsigned int dstcount; /*in frames*/
	unsigned int dststart; /*in frames*/
	qbyte *dstdata;

	unsigned int srcspeed;
	unsigned int srcwidth;
	unsigned int srcchannels;
	unsigned int srcoffset; /*in bytes*/
	unsigned int srclen;	/*in bytes*/
	qbyte srcdata[1];

	char title[256];
} mp3decoder_t;

static void QDECL S_MP3_Purge(sfx_t *sfx)
{
	mp3decoder_t *dec = sfx->decoder.buf;

	sfx->decoder.buf = NULL;
	sfx->decoder.ended = NULL;
	sfx->decoder.purge = NULL;
	sfx->decoder.decodedata = NULL;

	qacmStreamClose(dec->acm, 0);

	if (dec->dstdata)
		BZ_Free(dec->dstdata);
	BZ_Free(dec);

	sfx->loadstate = SLS_NOTLOADED;
}

float QDECL S_MP3_Query(sfx_t *sfx, sfxcache_t *buf, char *title, size_t titlesize)
{
	mp3decoder_t *dec = sfx->decoder.buf;
	//we don't know unless we decode it all
	if (buf)
	{
	}
	if (titlesize && dec->srclen >= 128)
	{	//id3v1 is a 128 byte blob at the end of the file.
		char trimartist[31];
		char trimtitle[31];
		char *p;
		struct
		{
			char tag[3];	//TAG
			char title[30];
			char artist[30];
			char album[30];
			char year[4];
			char comment[30];//[28]+null+track
			qbyte genre;
		} *id3v1 = (void*)(dec->srcdata + dec->srclen-128);
		if (id3v1->tag[0] == 'T' && id3v1->tag[1] == 'A' && id3v1->tag[2] == 'G')
		{	//yup, there's an id3v1 tag there
			memcpy(trimartist, id3v1->artist, 30);
			for(p = trimartist+30; p>trimartist && p[-1] == ' '; )
				p--;
			*p = 0;
			memcpy(trimtitle, id3v1->title, 30);
			for(p = trimtitle+30; p>trimtitle && p[-1] == ' '; )
				p--;
			*p = 0;
			if (*trimartist && *trimtitle)
				Q_snprintfz(title, titlesize, "%.30s - %.30s", trimartist, trimtitle);
			else if (*id3v1->title)
				Q_snprintfz(title, titlesize, "%.30s", trimtitle);
		}
		return 1;//no real idea.
	}
	return 0;
}

/*must be thread safe*/
sfxcache_t *QDECL S_MP3_Locate(sfx_t *sfx, sfxcache_t *buf, ssamplepos_t start, int length)
{
	int newlen;
	if (buf)
	{
		mp3decoder_t *dec = sfx->decoder.buf;
		ACMSTREAMHEADER strhdr;
		char buffer[8192];
		extern cvar_t snd_linearresample_stream;
		int framesz = (dec->srcwidth/8 * dec->srcchannels);

		if (length)
		{
			if (dec->dststart > start)
			{
				/*I don't know where the compressed data is for each sample. acm doesn't have a seek. so reset to start, for music this should be the most common rewind anyway*/
				dec->dststart = 0;
				dec->dstcount = 0;
				dec->srcoffset = 0;
			}

			if (dec->dstcount > snd_speed*6)
			{
				int trim = dec->dstcount - snd_speed; //retain a second of buffer in case we have multiple sound devices
				if (dec->dststart + trim > start)
				{
					trim = start - dec->dststart;
					if (trim < 0)
						trim = 0;
				}
	//			if (trim < 0)
	//				trim = 0;
	///			if (trim > dec->dstcount)
	//				trim = dec->dstcount;
				memmove(dec->dstdata, dec->dstdata + trim*framesz, (dec->dstcount - trim)*framesz);
				dec->dststart += trim;
				dec->dstcount -= trim;
			}

			while(start+length >= dec->dststart+dec->dstcount)
			{
				memset(&strhdr, 0, sizeof(strhdr));
				strhdr.cbStruct = sizeof(strhdr);
				strhdr.pbSrc = dec->srcdata + dec->srcoffset;
				strhdr.cbSrcLength = dec->srclen - dec->srcoffset;
				if (!strhdr.cbSrcLength)
					break;
				strhdr.pbDst = buffer;
				strhdr.cbDstLength = sizeof(buffer);

				qacmStreamPrepareHeader(dec->acm, &strhdr, 0);
				qacmStreamConvert(dec->acm, &strhdr, ACM_STREAMCONVERTF_BLOCKALIGN);
				qacmStreamUnprepareHeader(dec->acm, &strhdr, 0);
				dec->srcoffset += strhdr.cbSrcLengthUsed;
				if (!strhdr.cbDstLengthUsed)
				{
					if (strhdr.cbSrcLengthUsed)
						continue;
					break;
				}

				newlen = dec->dstcount + (strhdr.cbDstLengthUsed * ((float)snd_speed / dec->srcspeed))/framesz;
				if (dec->dstbuffer < newlen+64)
				{
					dec->dstbuffer = newlen+64 + snd_speed;
					dec->dstdata = BZ_Realloc(dec->dstdata, dec->dstbuffer*framesz);
				}

				SND_ResampleStream(strhdr.pbDst, 
					dec->srcspeed, 
					dec->srcwidth/8, 
					dec->srcchannels, 
					strhdr.cbDstLengthUsed / framesz,
					dec->dstdata+dec->dstcount*framesz,
					snd_speed,
					dec->srcwidth/8,
					dec->srcchannels,
					snd_linearresample_stream.ival);
				dec->dstcount = newlen;
			}
		}

		buf->data = dec->dstdata;
		buf->length = dec->dstcount;
		buf->numchannels = dec->srcchannels;
		buf->soundoffset = dec->dststart;
		buf->speed = snd_speed;
		buf->width = dec->srcwidth/8;

		if (dec->srclen == dec->srcoffset && start >= dec->dststart+dec->dstcount)
			return NULL;	//once we reach the EOF, start reporting errors.
	}
	return buf;
}

#ifndef WAVE_FORMAT_MPEGLAYER3
#define WAVE_FORMAT_MPEGLAYER3 0x0055
typedef struct
{
	WAVEFORMATEX  wfx;
	WORD          wID;
	DWORD         fdwFlags;
	WORD          nBlockSize;
	WORD          nFramesPerBlock;
	WORD          nCodecDelay;
} MPEGLAYER3WAVEFORMAT;
#endif
#ifndef MPEGLAYER3_ID_MPEG
#define MPEGLAYER3_WFX_EXTRA_BYTES 12
#define MPEGLAYER3_FLAG_PADDING_OFF 2
#define MPEGLAYER3_ID_MPEG 1
#endif

static qboolean QDECL S_LoadMP3Sound (sfx_t *s, qbyte *data, size_t datalen, int sndspeed, qboolean forcedecode)
{
	WAVEFORMATEX pcm_format;
	MPEGLAYER3WAVEFORMAT mp3format;
	HACMDRIVER drv = NULL;
	mp3decoder_t *dec;

	char ext[8];
	COM_FileExtension(s->name, ext, sizeof(ext));
	if (stricmp(ext, "mp3"))
		return false;

	dec = BZF_Malloc(sizeof(*dec) + datalen);
	if (!dec)
		return false;
	memcpy(dec->srcdata, data, datalen);
	dec->srclen = datalen;
	s->decoder.buf = dec;
	s->decoder.ended = S_MP3_Purge;
	s->decoder.purge = S_MP3_Purge;
	s->decoder.decodedata = S_MP3_Locate;
	s->decoder.querydata = S_MP3_Query;
	s->loopstart = -1;
	
	dec->dstdata = NULL;
	dec->dstcount = 0;
	dec->dststart = 0;
	dec->dstbuffer = 0;
	dec->srcoffset = 0;

	dec->srcspeed = 44100;
	dec->srcchannels = 2;
	dec->srcwidth = 16;

	memset (&pcm_format, 0, sizeof(pcm_format));
	pcm_format.wFormatTag = WAVE_FORMAT_PCM;
	pcm_format.nChannels = dec->srcchannels;
	pcm_format.nSamplesPerSec = dec->srcspeed;
	pcm_format.nBlockAlign = dec->srcwidth/8*dec->srcchannels;
	pcm_format.nAvgBytesPerSec = pcm_format.nSamplesPerSec*dec->srcwidth/8*dec->srcchannels;
	pcm_format.wBitsPerSample = dec->srcwidth;
	pcm_format.cbSize = 0;

	mp3format.wfx.cbSize = MPEGLAYER3_WFX_EXTRA_BYTES;
	mp3format.wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3;
	mp3format.wfx.nChannels = dec->srcchannels;
	mp3format.wfx.nAvgBytesPerSec = 128 * (1024 / 8);  // not really used but must be one of 64, 96, 112, 128, 160kbps
	mp3format.wfx.wBitsPerSample = 0;                  // MUST BE ZERO
	mp3format.wfx.nBlockAlign = 1;                     // MUST BE ONE
	mp3format.wfx.nSamplesPerSec = dec->srcspeed;       // 44.1kHz
	mp3format.fdwFlags = MPEGLAYER3_FLAG_PADDING_OFF;
	mp3format.nBlockSize = 522;					       // voodoo value #1 - 144 x (bitrate / sample rate) + padding
	mp3format.nFramesPerBlock = 1;                     // MUST BE ONE
	mp3format.nCodecDelay = 0;//1393;                      // voodoo value #2
	mp3format.wID = MPEGLAYER3_ID_MPEG;

	if (!qacmStartup() || 0!=qacmStreamOpen(&dec->acm, drv, (WAVEFORMATEX*)&mp3format, &pcm_format, NULL, 0, 0, 0))
	{
		Con_Printf("Couldn't init decoder\n");
		return false;
	}

	S_MP3_Locate(s, NULL, 0, 100);


	return true;
}
#endif



void Media_Init(void)
{
#ifdef HAVE_JUKEBOX
	int i;
	Cmd_AddCommand("music_fforward", Media_FForward_f);
	Cmd_AddCommand("music_rewind", Media_Rewind_f);
	Cmd_AddCommand("music_next", Media_Next_f);
	Cmd_AddCommand("media_next", Media_Next_f);

	Cvar_Register(&music_playlist_index, "compat");
	for (i = 0; i < 6; i++)
	{
		Cvar_Get(va("music_playlist_list%i", i), "", 0, "compat");
		Cvar_Get(va("music_playlist_sampleposition%i", i), "-1", 0, "compat");
	}
	music_playlist_last = -1;
	media_playlisttypes = MEDIA_PLAYLIST | MEDIA_GAMEMUSIC | MEDIA_CVARLIST;

	#ifdef WINAMP
		Cvar_Register(&media_hijackwinamp,	"Media player things");
	#endif
	Cvar_Register(&media_shuffle,	"Media player things");
	Cvar_Register(&media_repeat,	"Media player things");
	Cmd_AddCommand ("media_add", M_Media_Add_f);
	Cmd_AddCommand ("media_remove", M_Media_Remove_f);
	#if !defined(NOMEDIAMENU) && !defined(NOBUILTINMENUS)
		Cmd_AddCommand ("menu_media", M_Menu_Media_f);
	#endif
#endif
	Cvar_Register(&music_fade,	"Media player things");

#ifdef HAVE_SPEECHTOTEXT
	Cmd_AddCommand("tts", TTS_Say_f);
	Cmd_AddCommand("stt", STT_Init_f);
	Cvar_Register(&tts_mode, "Gimmicks");
#endif
#ifdef AVAIL_MP3_ACM
	S_RegisterSoundInputPlugin(S_LoadMP3Sound);
#endif


#ifdef HAVE_CDPLAYER
	Cmd_AddCommand("cd", CD_f);
	cdenabled = false;
	if (COM_CheckParm("-nocdaudio"))
		cdenabled = false;
	if (COM_CheckParm("-cdaudio"))
		cdenabled = true;
#endif

#ifdef HAVE_MEDIA_ENCODER
	#if defined(HAVE_API_VFW)
		Media_RegisterEncoder(NULL, &capture_avi);
	#endif
	#ifdef _DEBUG
		Media_RegisterEncoder(NULL, &capture_null);
	#endif
	Media_RegisterEncoder(NULL, &capture_raw);

	Cmd_AddCommandD("capture", Media_RecordFilm_f, "Captures realtime action to a named video file. Check the capture* cvars to control driver/codecs/rates.");
	Cmd_AddCommandD("capturedemo", Media_RecordDemo_f, "Capture a nemed demo to a named video file. Demo capturing can be performed offscreen, allowing arbitrary video sizes, or smooth captures on underpowered hardware.");
	Cmd_AddCommandD("capturestop", Media_StopRecordFilm_f, "Aborts the current video capture.");
	Cmd_AddCommandD("capturepause", Media_CapturePause_f, "Pauses the video capture, allowing you to avoid capturing uninteresting parts. This is a toggle, so reuse the same command to resume capturing again.");

	Cvar_Register(&capturemessage,			"Video Capture Controls");
	Cvar_Register(&capturesound,			"Video Capture Controls");
	Cvar_Register(&capturerate,				"Video Capture Controls");
	Cvar_Register(&capturewidth,			"Video Capture Controls");
	Cvar_Register(&captureheight,			"Video Capture Controls");
	Cvar_Register(&capturedriver,			"Video Capture Controls");
	Cvar_Register(&capturecodec,			"Video Capture Controls");
	Cvar_Register(&capturethrottlesize,		"Video Capture Controls");
	Cvar_Register(&capturesoundbits,		"Video Capture Controls");
	Cvar_Register(&capturesoundchannels,	"Video Capture Controls");
#endif

#ifdef HAVE_MEDIA_DECODER
	Cmd_AddCommand("playclip", Media_PlayVideoWindowed_f);
	Cmd_AddCommand("playvideo", Media_PlayFilm_f);
	Cmd_AddCommand("playfilm", Media_PlayFilm_f);
	Cmd_AddCommand("cinematic", Media_PlayFilm_f);
#endif

	Cmd_AddCommand("music", Media_NamedTrack_f);
	Cmd_AddCommand("stopmusic", Media_StopTrack_f);
}