Initial community commit

37 files changed, 10467 insertions, 0 deletions

diff --git a/Src/nsv/dec_if.h b/Src/nsv/dec_if.h
new file mode 100644
index 00000000..d0232327
--- /dev/null
+++ b/Src/nsv/dec_if.h
@@ -0,0 +1,98 @@
+/*
+** dec_if.h - common decoder interface for nsvplay/nsvplayx
+**
+** Copyright (C) 2001-2003 Nullsoft, Inc.
+**
+** This software is provided 'as-is', without any express or implied warranty.  
+** In no event will the authors be held liable for any damages arising from the use of this software.
+**
+** Permission is granted to anyone to use this software for any purpose, including commercial 
+** applications, and to alter it and redistribute it freely, subject to the following restrictions:
+**  1. The origin of this software must not be misrepresented; you must not claim that you wrote the 
+**     original software. If you use this software in a product, an acknowledgment in the product 
+**     documentation would be appreciated but is not required.
+**  2. Altered source versions must be plainly marked as such, and must not be misrepresented as 
+**     being the original software.
+**  3. This notice may not be removed or altered from any source distribution.
+**
+*/
+
+#ifndef _NSV_DEC_IF_H_
+#define _NSV_DEC_IF_H_
+
+#ifndef _WA_IPC_H_ // these are also defined in Winamp/wa_ipc.h
+struct YV12_PLANE {
+	unsigned char*	baseAddr;
+	long			rowBytes;
+} ;
+
+struct YV12_PLANES {
+	YV12_PLANE	y;
+	YV12_PLANE	u;
+	YV12_PLANE	v;
+} ;
+#endif
+
+class IVideoDecoder
+{
+  public:
+    virtual ~IVideoDecoder() { }
+
+    // decode returns 0 on success
+    // but *out can be NULL, meaning no new frame is available,
+    // but all is well
+    virtual int decode(int need_kf, 
+            void *in, int in_len, 
+            void **out, // out is set to a pointer to data
+            unsigned int *out_type, // 'Y','V','1','2' is currently defined
+            int *is_kf)=0;
+    virtual void flush()=0;
+};
+
+class IAudioDecoder
+{
+  public:
+    virtual ~IAudioDecoder() { }
+
+    // returns -1 on error, 0 on success (done with data in 'in'), 1 on success
+    // but to pass 'in' again next time around.
+    virtual int decode(void *in, int in_len, 
+                       void *out, int *out_len, // out_len is read and written to
+                       unsigned int out_fmt[8])=0; // out_fmt is written to
+                                                   // ex: 'PCM ', srate, nch, bps
+                                                   // or 'NONE' :)
+    virtual void flush()=0;
+};
+
+class IAudioOutput
+{
+  public:
+    virtual ~IAudioOutput() { }
+    virtual int canwrite()=0; // returns bytes writeable
+    virtual void write(void *buf, int len)=0;
+    virtual unsigned long long getpos()=0;
+    virtual unsigned long long getwritepos()=0;
+    virtual void flush(unsigned int newtime)=0;
+    virtual int isplaying(void) { return 1; }
+    virtual void pause(int pause) { }
+    virtual void setvolume(int volume) { }
+    virtual void setpan(int pan) { }
+    virtual void getdescstr(char *buf) { *buf=0; }
+};
+
+
+/*
+** The DLL must export one of these symbols (unmangled, i.e. using extern "C).
+**
+** IAudioDecoder *CreateAudioDecoder(unsigned int type, IAudioOutput **output);
+** IVideoDecoder *CreateVideoDecoder(int w, int h, double framerate, unsigned int type, int *flip);
+**
+** the functions should return NULL if the conversion is not possible (or 
+** is not the correct format)
+**
+** The DLL must be in <program files>\common files\nsv, and must be named
+** nsvdec_*.dll.
+** 
+*/
+
+#endif//_NSV_DEC_IF_H_
diff --git a/Src/nsv/enc_if.h b/Src/nsv/enc_if.h
new file mode 100644
index 00000000..65daf32f
--- /dev/null
+++ b/Src/nsv/enc_if.h
@@ -0,0 +1,44 @@
+/*
+** enc_if.h - common encoder interface
+**
+** Copyright (C) 2001-2003 Nullsoft, Inc.
+**
+** This software is provided 'as-is', without any express or implied warranty.  
+** In no event will the authors be held liable for any damages arising from the use of this software.
+**
+** Permission is granted to anyone to use this software for any purpose, including commercial 
+** applications, and to alter it and redistribute it freely, subject to the following restrictions:
+**  1. The origin of this software must not be misrepresented; you must not claim that you wrote the 
+**     original software. If you use this software in a product, an acknowledgment in the product 
+**     documentation would be appreciated but is not required.
+**  2. Altered source versions must be plainly marked as such, and must not be misrepresented as 
+**     being the original software.
+**  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _NSV_ENC_IF_H_
+#define _NSV_ENC_IF_H_
+class VideoCoder
+{
+  public:
+    VideoCoder() { }
+    virtual int Encode(void *in, void *out, int *iskf)=0; // returns bytes in out
+    virtual ~VideoCoder() { };
+};
+
+class AudioCoder 
+{
+  public:
+    AudioCoder() { }
+    virtual int Encode(int framepos, void *in, int in_avail, int *in_used, void *out, int out_avail)=0; //returns bytes in out
+    virtual ~AudioCoder() { };
+};
+
+// unsigned int GetAudioTypes3(int idx, char *desc);
+// unsigned int GetVideoTypes3(int idx, char *desc);
+// AudioCoder *CreateAudio3(int nch, int srate, int bps, unsigned int srct, unsigned int *outt, char *configfile);
+// VideoCoder *CreateVideo3(int w, int h, double frt, unsigned int pixt, unsigned int *outt, char *configfile);
+// HWND ConfigAudio3(HWND hwndParent, HINSTANCE hinst, unsigned int outt, char *configfile);
+// HWND ConfigVideo3(HWND hwndParent, HINSTANCE hinst, unsigned int outt, char *configfile);
+
+#endif //_NSV_ENC_IF_H_
diff --git a/Src/nsv/nsvbs.h b/Src/nsv/nsvbs.h
new file mode 100644
index 00000000..9ec59ef1
--- /dev/null
+++ b/Src/nsv/nsvbs.h
@@ -0,0 +1,202 @@
+/*
+** nsvbs.h - NSV basic inline bitstream classes
+**
+** Copyright (C) 2001-2002 Nullsoft, Inc.
+** Confidential Subject to NDA
+**
+** Note: these bitstream classes encode/decode everything in LSB.
+** bits are stored from the lowest bit to the highest bit.
+**  putbits(4,0xE) will result in getbits(1)=0, getbits(1)=1, 
+**                                getbits(1)=1, getbits(1)=1
+**    or of course, getbits(4) == 0xE :)
+*/
+
+#ifndef _NSVBS_H_
+#define _NSVBS_H_
+
+#include <stdlib.h>
+#include <memory.h>
+#include <bfc/platform/types.h>
+#include "../nu/GrowBuf.h"
+
+class nsv_OutBS
+{
+public:
+	nsv_OutBS() { m_used = 0; m_curb=0; }
+	~nsv_OutBS() { }
+
+	void putbits(int nbits, unsigned int value)
+	{
+		while (nbits-- > 0)
+		{
+			m_curb|=(value&1)<<(m_used&7);
+			if (!((++m_used)&7))
+			{
+				m_bits.add(&m_curb,1);
+				m_curb=0;
+			}
+			value>>=1;
+		}
+	}
+
+    // lets you put in any amount of data, but does not preserve endianness.
+	void putdata(int nbits, void *data) 
+	{
+		unsigned char *c=(unsigned char *)data;
+		if (!(m_used&7) && nbits >= 8)
+		{
+			m_bits.add(c,nbits/8);
+			c+=nbits/8;
+			m_used+=nbits&~7;
+			nbits&=7;
+		}
+		while (nbits > 0)
+		{
+			int tb=nbits;
+			if (tb > 8) tb=8;
+			putbits(tb,*c++);
+			nbits-=tb;
+		}
+	}
+
+	int getlen() { return m_used; } // in bits
+
+	void *get(int *len) // len is in bytes, forces to byte aligned.
+	{
+		if (m_used&7)
+		{
+			m_bits.add(&m_curb,1);
+			m_used=(m_used+7)&~7;
+			m_curb=0;
+		}
+		*len=m_used/8;
+		return m_bits.get();
+	}
+
+	void clear()
+	{
+		m_used=0;
+		m_curb=0;
+		m_bits.resize(0);
+	}
+
+private:
+	GrowBuf m_bits;
+	int m_used; // bits
+	unsigned char m_curb;
+};
+
+class nsv_InBS {
+public:
+	nsv_InBS() { m_bitpos=0; m_eof=0; }
+	~nsv_InBS() { }
+
+	void clear() 
+	{
+	    m_eof=0;
+		m_bitpos=0;
+		m_bits.resize(0);
+	}
+
+	void add(void *data, int len)
+	{
+		m_bits.add(data,len);
+		m_eof=0;
+	}
+
+	void addbyte(unsigned char byte)
+	{
+		add(&byte,1);
+	}
+
+	void addint(unsigned int dword)
+	{
+		addbyte(dword&0xff);
+		addbyte((dword>>8)&0xff);
+		addbyte((dword>>16)&0xff);
+		addbyte((dword>>24)&0xff);
+	}
+  
+	void compact()
+	{
+		size_t bytepos=m_bitpos/8;
+		if (bytepos)
+		{
+			unsigned char *t=(unsigned char *)m_bits.get();
+			size_t l=m_bits.getlen()-bytepos;
+			memcpy(t,t+bytepos,l);
+			m_bits.resize(l);
+			m_bitpos&=7;
+		}
+		m_eof=0;
+	}
+
+	void seek(ptrdiff_t nbits) 
+	{
+		if (nbits < 0 && ((size_t)(-nbits)) > m_bitpos)
+			m_bitpos=0;
+		else
+			m_bitpos+=nbits;
+		m_eof=m_bits.getlen()*8 < m_bitpos; 
+	}
+
+	void rewind() { m_bitpos=0; m_eof=0; }
+	int eof() { return m_eof; }
+	size_t avail() { if (m_eof) return 0; return m_bits.getlen()*8 - m_bitpos; }
+
+	unsigned int getbits(size_t nbits)
+	{
+		unsigned int ret=0;
+		if (!nbits) return ret;
+		unsigned char *t=(unsigned char *)m_bits.get();
+
+		if (!t || m_bits.getlen()*8 < m_bitpos+nbits) m_eof=1;
+		else
+		{
+			t+=m_bitpos/8;
+			for (size_t sh = 0; sh != nbits; sh ++)
+			{
+				ret|=((*t>>(m_bitpos&7))&1) << sh;
+				if (!((++m_bitpos)&7)) t++;
+			}
+		}
+		return ret;
+	}
+
+	int getdata(size_t nbits, void *data)
+	{
+		unsigned char *t=(unsigned char *)data;
+		if (m_bits.getlen()*8 < m_bitpos+nbits) return 1;
+		if (!(m_bitpos&7) && nbits >= 8)
+		{
+			char *bitptr=(char*)m_bits.get();
+			bitptr+=(m_bitpos/8);
+			memcpy(t,bitptr,nbits/8);
+			m_bitpos+=nbits&~7;
+
+			t+=nbits/8;
+			nbits&=7;
+		}
+		while (nbits > 0)
+		{
+			size_t nb=nbits;
+			if (nb > 8) nb=8;
+			*t++=getbits(nb);
+			nbits-=nb;
+		}
+		return 0;
+	}
+
+	void *getcurbyteptr()
+	{
+		char *t=(char*)m_bits.get();
+		return (void *)(t+(m_bitpos/8));
+	}
+
+private:
+	GrowBuf m_bits;
+	size_t m_bitpos;
+	int m_eof;
+};
+
+#endif//_NSVBS_H_
\ No newline at end of file
diff --git a/Src/nsv/nsvencode.h b/Src/nsv/nsvencode.h
new file mode 100644
index 00000000..39f1f907
--- /dev/null
+++ b/Src/nsv/nsvencode.h
@@ -0,0 +1,221 @@
+#ifndef _NSVENCODE_H_
+#define _NSVENCODE_H_
+
+#include "../jnetlib/jnetlib.h"
+#include "nsvlib.h"
+#include "enc_if.h"
+#include <stdio.h>
+
+class nsv_Encoder
+{
+  public:
+    nsv_Encoder();
+    ~nsv_Encoder();
+
+
+    static void freeCoders(); // call this before quitting if you used any nsvencoders
+    static void loadCoders();
+    static HWND configAudio(unsigned int audfmt, HWND hwndParent, char *configfile);
+    static HWND configVideo(unsigned int vidfmt, HWND hwndParent, char *configfile);
+    static int enumAudio(int *state, char *name, unsigned int *fmt);
+    static int enumVideo(int *state, char *name, unsigned int *fmt);
+
+
+    char *getError() { return m_err; } // NULL on no error
+
+    // compressor configuration (do not call these after calling openOutput())
+    void setVideo(unsigned int vfmt, unsigned int w, unsigned int h, double frt, 
+                  unsigned int srcfmt=NSV_MAKETYPE('R','G','B','A'),
+                   char *configfile=NULL);
+    void setAudio(unsigned int afmt, int srate, int nch, int bps, 
+                  unsigned int srcfmt=NSV_MAKETYPE('P','C','M',' '),
+                   char *configfile=NULL);
+
+    // stream configuration (do not call these after calling openOutput())
+    void setMaxAudioSendAhead(int offs) { m_audio_ahead_of_video=offs; }
+    void setSyncFrameInterval(int minimum=0, int maximum=120) { m_max_syncframe_dist=maximum; m_min_syncframe_dist=minimum; }
+
+    // setting one of these will enable file header writing on files
+    // do NOT call these after calling openOutput(),
+    int addHdrMetaData(char *name, char *data, int data_len); // returns nonzero on error
+    int setHdrMetaData(char *data, int data_len); // nonzero on error
+    void setHdrTOCSize(int tocsize);
+    void forceHdrWrite() { m_usefilehdr=1; } // use if you dont want meta or toc, but want a basic header
+
+    // output (call only once, do not close and reopen (yet))
+    void openOutput(char *url); // call getError to check for error
+    void closeOutput();
+    
+    // encode (call only after openoutput())
+    void addAudioData(void *data, int data_len);
+    int needAudioData(); // returns 1 if more audio data would be nice for sync, 2 if there is no audio data in buffer
+
+    // for audio only, use compressor type NONE and call this with NULL 
+    void addVideoFrame(void *frame);
+    // calling this will put the aux data in the same frame as the NEXT addVideoFrame()
+    void addAuxData(unsigned int fmt, void *data, int data_len);
+    
+    // setting audio eof will let the audio compressor know that it is the end of stream
+    // so that it can flush (via passing an empty frame to it)
+    void set_audioEof(int eof) { m_audio_eof=!!eof; }
+    int get_audioEof() { return m_audio_eof; }
+
+    // stats
+    unsigned int getCurrentBitrate()
+    {
+      if (m_video_position_frames)
+        return (unsigned int) ((double) m_bitstreambytesout / ((double) m_video_position_frames / m_framerate) * 8.0);
+      return 0;
+    }
+
+
+  private:
+
+    char *m_err;
+
+    int m_usefilehdr;
+    unsigned int m_tocsize;
+    int m_audio_channels;
+    int m_audio_samplerate;
+    int m_audio_bits;
+    unsigned int m_audio_srcfmt;
+    unsigned int m_audio_coder;
+    char *m_audio_configfile;
+
+
+    double m_framerate;
+    unsigned int m_w, m_h;
+    unsigned int m_video_coder;
+    unsigned int m_video_srcfmt;
+    char *m_video_configfile;
+
+    int m_audio_ahead_of_video;
+
+    int m_max_syncframe_dist,m_min_syncframe_dist;
+    nsv_fileHeader m_filehdr;
+
+    FILE *m_outfile;
+    JNL_Connection *m_outcon;
+    int m_is_uvox; // for m_outco
+    char *m_outcon_host,*m_outcon_headers;
+    int m_outcon_port;
+    unsigned int m_outcon_last_connect_time;
+
+    nsv_Packeter m_packeter;
+    nsv_InBS m_outconbs;
+    __int64 m_bitstreambytesout;
+
+    AudioCoder *m_audcoder;
+    VideoCoder *m_vidcoder;
+
+    __int64 m_audio_position_bytes;
+    __int64 m_video_position_frames;
+    char m_vidobuf[NSV_MAX_VIDEO_LEN];
+    char m_audobuf[NSV_MAX_AUDIO_LEN];
+    nsv_InBS m_audibuf;
+    unsigned int m_total_frames;
+    nsv_GrowBuf m_tocEntries;
+    int m_frames_since_last_sync_frame;
+    int m_audio_eof;
+
+    void send_uvoxmessage(int msgclass, int msgtype, void *msg, int msglen);
+
+
+    static VideoCoder *init_video(int w, int h, double frt, unsigned int pixt, unsigned int *outt, char *configfile);
+    static AudioCoder *init_audio(int nch, int srate, int bps, unsigned int srct, unsigned int *outt, char *configfile);
+    static int Coders_loaded;
+    static HINSTANCE g_Coders[256];
+    static int g_numCoders;
+    static char g_dll_dir[MAX_PATH];
+    static BOOL CALLBACK PcmProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
+
+
+
+};
+
+
+
+class nsv_EncoderConfigFile
+{
+  public:
+
+    nsv_EncoderConfigFile(char *filename=NULL) 
+    { 
+      m_filename=filename?_strdup(filename):0; 
+      m_audfmt=m_vidfmt=0;
+      m_minsync=0;
+      m_maxsync=120;
+      m_audiosendahead=0;
+      m_hdrwrite=0;
+      m_hdrtoc=1024;
+      m_metadata=0;
+	  m_crop_l=0;	// ##
+	  m_crop_r=0;	// ##
+	  m_crop_t=0;	// ##
+	  m_crop_b=0;	// ##
+
+      ReadIn();
+    }
+
+
+    ~nsv_EncoderConfigFile(); //ak 7-23-03 moved so breakpoint can be set
+    unsigned int getVidFmt() { return m_vidfmt; }
+    unsigned int getAudFmt() { return m_audfmt; }
+    void setVidFmt(unsigned int fmt) { m_vidfmt=fmt; }
+    void setAudFmt(unsigned int fmt) { m_audfmt=fmt; }
+
+    char *getFilename() { return m_filename; }
+    void setFilename(char *filename) 
+    { 
+      FlushOut();
+      free(m_filename); 
+      if (filename) 
+      {
+        m_filename=_strdup(filename); 
+        ReadIn();
+      }
+      else m_filename=0; 
+    }
+
+    int getMinSyncFrameInt() { return m_minsync; }
+    void setMinSyncFrameInt(int minint) { m_minsync=minint; }
+    int getMaxSyncFrameInt() { return m_maxsync; }
+    void setMaxSyncFrameInt(int maxint) { m_maxsync=maxint; }
+    int getAudioSendAhead() { return m_audiosendahead; }
+    void setAudioSendAhead(int sa) { m_audiosendahead=sa; }
+
+    char *hdrGetMetadata() { return m_metadata; }
+    int hdrGetDoWrite() { return m_hdrwrite; }
+    int hdrSetDoWrite(int dw) { m_hdrwrite=!!dw; }
+    int hdrGetTOCSize() { return m_hdrtoc; }
+    int hdrSetTOCSize(int ts) { m_hdrtoc=ts; }
+
+    int ConfigUI(HINSTANCE hInstance, HWND hwndParent);
+
+  private:
+
+    void FlushOut();
+    void ReadIn();
+
+    static BOOL CALLBACK _dialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
+    BOOL dialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
+    HWND audio_hwnd, video_hwnd;
+    void initConfigChildWindows(HWND hwndDlg, int flags);
+
+    char *m_filename;
+
+    unsigned int m_audfmt,m_vidfmt;
+    int m_minsync, m_maxsync;
+    int m_audiosendahead;
+    int m_hdrwrite;
+    int m_hdrtoc;
+    char *m_metadata;
+
+  public:
+	int m_crop_l;	// ##
+	int m_crop_r;	// ##
+	int m_crop_t;	// ##
+	int m_crop_b;	// ##
+};
+
+#endif//_NSVENCODE_H_
\ No newline at end of file
diff --git a/Src/nsv/nsvlib.cpp b/Src/nsv/nsvlib.cpp
new file mode 100644
index 00000000..e26bef2f
--- /dev/null
+++ b/Src/nsv/nsvlib.cpp
@@ -0,0 +1,737 @@
+/*
+** nsvlib.cpp - NSV file/bitstream reading/writing code
+** 
+** Copyright (C) 2001-2002 Nullsoft, Inc.
+**
+** Confidential Subject to NDA
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <bfc/platform/strcmp.h>
+
+#include "nsvlib.h"
+
+#define NSV_HDR_DWORD (NSV_MAKETYPE('N','S','V','f'))
+
+#define NSV_SYNC_HEADERLEN_BITS 192
+#define NSV_SYNC_DWORD (NSV_MAKETYPE('N','S','V','s'))
+#define NSV_NONSYNC_HEADERLEN_BITS 56
+#define NSV_NONSYNC_WORD 0xBEEF
+
+#define NSV_INVALID_SYNC_OFFSET 0x80000000
+
+long	glSyncFrameCount = 0l;
+long	glCounterNSVf = 0l;
+long	glNonSyncFrameCount = 0l;
+
+/*
+  NSV sync packet header
+  32 bits: NSV_SYNC_DWORD
+  32 bits: video format
+  32 bits: audio format
+  16 bits: width
+  16 bits: height
+  8  bits: framerate (see getfrate/setfrate)
+
+
+  16 bits: audio/video sync offset
+
+or
+
+  NSV nonsync packet header
+  16 bits: NSV_NONSYNC_WORD
+
+then 
+
+4  bits: # aux data channels present (max 15)
+20 bits: video data + aux channels length
+16 bits: audio data length
+
+--------------------------------
+sync:
+  192 bit header, 
+  136 bits are invariant
+nonsync:
+  56 bit header
+  16 bits are invariant
+
+*/
+
+
+
+
+static int is_type_char_valid(int c)
+{
+  c&=0xff;
+  return (c >= 'a' && c <= 'z') ||
+         (c >= 'A' && c <= 'Z') ||
+         (c >= '0' && c <= '9') ||
+         c == ' ' || c == '-' || 
+         c == '.' || c == '_';
+}
+
+static int is_type_valid(unsigned int t)
+{
+  return (t&0xff) != ' ' &&
+          is_type_char_valid(t>>24) &&
+          is_type_char_valid(t>>16) &&
+          is_type_char_valid(t>>8) &&
+          is_type_char_valid(t);
+}
+
+
+void nsv_type_to_string(unsigned int t, char *out)
+{
+  if (is_type_valid(t))
+  {
+    out[0]=(t)&0xff;
+    out[1]=(t>>8)&0xff;
+    out[2]=(t>>16)&0xff;
+    out[3]=(t>>24)&0xff;
+    out[4]=0;
+    int x=3;
+    while (out[x]==' ' && x > 0) out[x--]=0;
+  }
+  else *out=0;
+}
+
+unsigned int nsv_string_to_type(char *in)
+{
+  int n;
+  unsigned int ret=*in;
+  if (*in == ' ' || !is_type_char_valid(*in)) return 0;
+  in++;
+  for (n = 0; n < 3; n ++)
+  {
+    if (!is_type_char_valid(*in)) break;
+    ret|=(*in<<(8+8*n));
+    in++;
+  }
+  if (*in) return 0;
+  return ret;
+}
+
+// frate is specified
+// XYYYYYZZ
+// if !X, framerate is YYYYYZZ (1-127)
+// otherwise:
+//   ZZ indexes base
+//   YYYYY is scale (0-32). 
+//     if YYYYY < 16, then scale = 1/(YYYY+1)
+//     otherwise scale = YYYYY-15
+
+
+static double frate2double(unsigned char fr)
+{
+  static double fratetab[]=
+  {
+    30.0,
+    30.0*1000.0/1001.0,
+    25.0,
+    24.0*1000.0/1001.0,
+  };
+  if (!(fr&0x80)) return (double)fr;
+
+  double sc;
+  int d=(fr&0x7f)>>2;
+  if (d < 16) sc=1.0/(double)(d+1);
+  else sc=d-15;
+
+  return fratetab[fr&3]*sc; 
+}
+
+
+
+static unsigned char double2frate(double fr)
+{
+  int best=0;
+  double best_v=1000000.0;
+  int x;
+  for (x = 0; x < 256; x ++)
+  {
+    double this_v=(fr-frate2double(x));
+
+    if (this_v<0) this_v=-this_v;
+    if (this_v < best_v) 
+    {
+      best_v=this_v;
+      best=x;
+    }
+  }
+  return (unsigned char) best;
+}
+
+
+
+nsv_Packeter::nsv_Packeter()
+{
+  vidfmt=audfmt=0;
+  width=height=0;
+  framerate_idx=0;
+  framerate=0.0;
+  syncoffset_cur=0;
+  video=NULL;
+  audio=NULL;
+  video_len=0;
+  audio_len=0;
+  aux_used=0;
+}
+
+void nsv_Packeter::setVidFmt(unsigned int vfmt, unsigned int w, unsigned int h, double frt)
+{
+  vidfmt=vfmt;
+  width=w;
+  height=h;
+  framerate=frt;
+  framerate_idx=double2frate(frt);
+}
+
+nsv_Packeter::~nsv_Packeter()
+{
+}
+
+int nsv_Packeter::packet(nsv_OutBS &bs)
+{
+  int total_auxlen=0;
+  int x;
+  if (width >= (1<<16) || height >= (1<<16) || 
+      !framerate_idx || framerate_idx > 255 ||
+      !is_type_valid(audfmt) || 
+      !is_type_valid(vidfmt) ||
+      video_len > NSV_MAX_VIDEO_LEN || 
+      audio_len > NSV_MAX_AUDIO_LEN ||
+      aux_used > NSV_MAX_AUXSTREAMS || 
+      aux_used < 0    
+    ) return -1;
+
+  for (x = 0; x < aux_used; x ++)
+  {
+    if (aux_len[x] > NSV_MAX_AUX_LEN) return -1;
+    total_auxlen+=aux_len[x]+6;
+  }
+  
+  if (is_sync_frame)
+  {
+    bs.putbits(32,NSV_SYNC_DWORD);
+    bs.putbits(32,vidfmt);
+    bs.putbits(32,audfmt);
+    bs.putbits(16,width);
+    bs.putbits(16,height);
+    bs.putbits(8 ,framerate_idx);
+    bs.putbits(16,syncoffset_cur);
+  }
+  else
+  {
+    bs.putbits(16,NSV_NONSYNC_WORD);
+  }
+  
+  bs.putbits(4,aux_used); // no aux data channels for our streams yet
+  bs.putbits(20,video_len+total_auxlen);
+  bs.putbits(16,audio_len);
+
+  for (x = 0; x < aux_used; x ++)
+  {
+    bs.putbits(16,aux_len[x]); // length of 0 for aux channels
+    bs.putbits(32,aux_types[x]);
+    if (aux_len[x]) bs.putdata(aux_len[x]*8,aux[x]);
+  }
+
+  if (video_len) bs.putdata(video_len*8,video);
+  if (audio_len) bs.putdata(audio_len*8,audio);
+
+  return 0;
+}
+
+
+void nsv_Unpacketer::reset(int full)
+{
+  synched=0;
+  is_sync_frame=0;
+  syncoffset_cur=0;
+  syncoffset=NSV_INVALID_SYNC_OFFSET;
+
+  if (full)
+  {
+    m_auxbs=NULL;
+    m_audiobs=NULL;
+    m_videobs=NULL;
+    m_eof=0;
+    vidfmt=0;
+    audfmt=0;
+    valid=0;
+    width=0;
+    height=0;
+    framerate=0.0;
+    framerate_idx=0;
+  }
+}
+
+
+// returns 0 on success, >0 on needs (at least X bytes) more data, 
+//   -1 on error (no header found in block)
+int nsv_Unpacketer::unpacket(nsv_InBS &bs)
+{
+  int gotframe=0;
+  unsigned int num_aux=0;
+  unsigned int vl=0;
+  unsigned int al=0;
+   
+  while (bs.avail()>=NSV_NONSYNC_HEADERLEN_BITS)
+  {
+    if (valid && synched)
+    {
+      if (bs.avail() < NSV_NONSYNC_HEADERLEN_BITS)
+        return m_eof?-1:(NSV_NONSYNC_HEADERLEN_BITS- (int)(bs.avail())/8);
+
+      unsigned int d=bs.getbits(16);
+      if (d == NSV_NONSYNC_WORD)
+      {
+		  glNonSyncFrameCount++;
+        num_aux=bs.getbits(4);
+        vl=bs.getbits(20);
+        al=bs.getbits(16);
+        if (al >= NSV_MAX_AUDIO_LEN || 
+            vl >= (NSV_MAX_VIDEO_LEN+num_aux*(NSV_MAX_AUX_LEN+6)))
+        {
+          bs.seek(-NSV_NONSYNC_HEADERLEN_BITS);
+        }
+        else
+        {
+          if ((unsigned int)bs.avail() < 8*(vl+al)+(m_eof?0:32))
+          {
+            int l=(al+vl+32/8)- (int)(bs.avail()/8);
+            bs.seek(-NSV_NONSYNC_HEADERLEN_BITS);
+            return m_eof?-1:l;
+          }
+
+          if ((unsigned int)bs.avail() >= 8*(vl+al)+32)
+          {
+            bs.seek(8*(vl+al));
+            unsigned int a32=bs.getbits(32);
+            bs.seek(-32);
+            unsigned int a16=bs.getbits(16);
+            bs.seek(-16);
+            bs.seek(-8*(vl+al));
+            if (a16 != NSV_NONSYNC_WORD && a32 != NSV_SYNC_DWORD)
+            {
+              bs.seek(-NSV_NONSYNC_HEADERLEN_BITS);
+            }
+            else gotframe=NSV_NONSYNC_HEADERLEN_BITS;
+          }
+          else gotframe=NSV_NONSYNC_HEADERLEN_BITS;
+        }
+      }
+      else bs.seek(-16);
+    } // inf.valid && inf.synched
+
+    // gotframe is set if we successfully got a nonsync frame, otherwise
+    // let's see if we can't interpret this as a sync frame
+
+    if (!gotframe)
+    {
+      if (bs.avail() < NSV_SYNC_HEADERLEN_BITS)
+        return (int)(m_eof?-1:(NSV_SYNC_HEADERLEN_BITS-(bs.avail())/8));
+      unsigned int d=bs.getbits(32);
+      if (d != NSV_SYNC_DWORD)
+      {
+        bs.seek(8-32); // seek back 3 bytes
+        synched=0;
+        continue;
+      }else{
+		  // count the # of sync frames (for debugging)
+		  glSyncFrameCount++;
+	  }
+      unsigned int vfmt=bs.getbits(32);
+      unsigned int afmt=bs.getbits(32);
+      unsigned int w=bs.getbits(16);
+      unsigned int h=bs.getbits(16);
+      unsigned char frt=bs.getbits(8);
+      unsigned int so=bs.getbits(16);
+
+      num_aux=bs.getbits(4);
+      vl=bs.getbits(20);
+      al=bs.getbits(16);
+
+      if (al >= NSV_MAX_AUDIO_LEN || 
+          vl >= (NSV_MAX_VIDEO_LEN+num_aux*(NSV_MAX_AUX_LEN+6)) ||
+          !frt || !is_type_valid(vfmt) || !is_type_valid(afmt) ||
+          (valid &&
+           (width != w || height != h ||
+            vidfmt != vfmt || audfmt != afmt || framerate_idx != frt)))
+      { // frame is definately not valid
+        bs.seek(8-NSV_SYNC_HEADERLEN_BITS); // seek back what we just read
+        synched=0;
+        continue;
+      }
+      
+      if ((unsigned int)bs.avail() < (al+vl)*8+((m_eof||(valid&&synched))?0:32))
+      {
+        int l=(al+vl)*8+NSV_SYNC_HEADERLEN_BITS- (int)(bs.avail());
+        bs.seek(-NSV_SYNC_HEADERLEN_BITS);
+        return m_eof?-1:(l/8);
+      }
+
+      if (valid && synched) 
+      {
+        gotframe=NSV_SYNC_HEADERLEN_BITS;
+      }
+      else // we need to do more robust sync
+      {
+        int sk=(al+vl)*8;
+        bs.seek(sk);
+        unsigned int a16=bs.getbits(16);
+        bs.seek(-16);
+        unsigned int a32=bs.getbits(32);
+        bs.seek(-32);
+        if (a16 == NSV_NONSYNC_WORD)
+        {
+          sk+=16+4+20+16;
+          bs.seek(16);
+          unsigned int _num_aux=bs.getbits(4);
+          unsigned int _vl=bs.getbits(20);
+          unsigned int _al=bs.getbits(16);
+          if ((unsigned int)bs.avail() < (_vl+_al)*8 + 32)
+          {
+            int l=(_al+_vl+32)- (int)(bs.avail()/8);
+            bs.seek(-NSV_SYNC_HEADERLEN_BITS-sk);
+            return m_eof?-1:l;
+          }
+          bs.seek((_vl+_al)*8);
+          sk+=(_vl+_al)*8;
+          unsigned int a16=bs.getbits(16);
+          bs.seek(-16);
+          unsigned int a32=bs.getbits(32);
+          bs.seek(-32);
+          bs.seek(-sk);
+          if (a16 == NSV_NONSYNC_WORD || a32 == NSV_SYNC_DWORD)
+            gotframe=NSV_SYNC_HEADERLEN_BITS;
+        }
+        else if (a32 == NSV_SYNC_DWORD)
+        {
+			glSyncFrameCount++;
+			
+			sk+=32+32+32+16+16+8;
+          
+          bs.seek(32);
+          unsigned int _vfmt=bs.getbits(32);
+          unsigned int _afmt=bs.getbits(32);
+          unsigned int _w=bs.getbits(16);
+          unsigned int _h=bs.getbits(16);
+          unsigned char _frt=bs.getbits(8);
+          bs.seek(-sk);
+
+          if (_vfmt==vfmt && _afmt==afmt && _w==w && _h==h && _frt==frt) // matches
+          {
+            gotframe=NSV_SYNC_HEADERLEN_BITS;
+          }
+        }
+      }
+      if (!gotframe)
+      {
+        synched=0;
+        bs.seek(8-NSV_SYNC_HEADERLEN_BITS);
+      }
+      else
+      {
+        if (so & 0x8000) so|=0xFFFF0000;       
+        syncoffset_cur=so;
+        if (!valid || syncoffset == NSV_INVALID_SYNC_OFFSET) syncoffset=so;
+        if (!valid) framerate=frate2double(frt);
+        framerate_idx=frt;
+        width=w;
+        height=h;
+        audfmt=afmt;
+        vidfmt=vfmt;
+        valid=1;
+        synched=1;
+      }
+    }
+
+    if (gotframe)
+    {
+      is_sync_frame = (gotframe == NSV_SYNC_HEADERLEN_BITS);
+      // read aux channels
+      int rd=gotframe;
+      unsigned int x;
+      for (x = 0; x < num_aux; x ++)
+      {
+        unsigned int l=bs.getbits(16);
+        unsigned int fmt=bs.getbits(32);
+        vl -= 4+2;
+        rd += 16+32;
+
+        if (l > NSV_MAX_AUX_LEN) break;
+
+        if (m_auxbs)
+        {
+          m_auxbs->addint(l);
+          m_auxbs->addint(fmt);
+          m_auxbs->add(bs.getcurbyteptr(),l);
+        }
+        bs.seek(l*8); // toss aux
+
+        vl-=l;
+        rd+=l*8;
+
+        if (vl<0) break; // invalid frame (aux channels add up to more than video)
+      }
+      if (x < num_aux) // oh shit, invalid frame
+      {
+        synched=0;
+        bs.seek(8-rd);
+        gotframe=0;
+        continue;
+      }
+    
+      if (m_videobs)
+      {
+        m_videobs->addint(vl);
+        m_videobs->add(bs.getcurbyteptr(),vl);
+      }
+      bs.seek(vl*8);
+
+      if (m_audiobs)
+      {
+        m_audiobs->addint(al);
+        m_audiobs->add(bs.getcurbyteptr(),al);
+      }
+      bs.seek(al*8);
+
+      return 0;
+    }
+  } // while
+  return m_eof?-1:(NSV_NONSYNC_HEADERLEN_BITS- (int)(bs.avail())/8);
+}
+
+
+
+
+
+
+
+
+
+/* NSV file header
+4: NSV_HDR_DWORD
+4: length of header in bytes
+    -- may not be 0 or 0xFFFFFFFF. :)
+4: length of file, in bytes (including header - if this is 0 we are invalid)
+    -- can be 0xFFFFFFFF which means unknown length
+4: length of file, in milliseconds (max file length, 24 days or so)
+    -- can be 0xFFFFFFFF which means unknown length
+4: metadata length
+4: number of TOC entries allocated
+4: number of TOC entries used
+mdlen: metadata
+TOC_alloc*4:offset in file at time t.
+*/
+
+void nsv_writeheader(nsv_OutBS &bs, nsv_fileHeader *hdr, unsigned int padto)
+{
+  if (hdr->toc_alloc < hdr->toc_size)
+    hdr->toc_alloc=hdr->toc_size;
+
+  if (hdr->toc_ex && hdr->toc_alloc <= hdr->toc_size*2)
+    hdr->toc_alloc=hdr->toc_size*2+1;
+
+  hdr->header_size = 4+4+4+4+4+hdr->metadata_len+4+4+4*hdr->toc_alloc;
+
+  bs.putbits(32,NSV_HDR_DWORD);
+  bs.putbits(32,hdr->header_size>padto?hdr->header_size:padto);
+  if (hdr->file_lenbytes == 0xFFFFFFFF) bs.putbits(32,hdr->file_lenbytes);
+  else bs.putbits(32,hdr->file_lenbytes+(hdr->header_size>padto?hdr->header_size:padto));
+  bs.putbits(32,hdr->file_lenms);
+  bs.putbits(32,hdr->metadata_len);
+  bs.putbits(32,hdr->toc_alloc);
+  bs.putbits(32,hdr->toc_size);
+  bs.putdata(hdr->metadata_len*8,hdr->metadata);
+
+  unsigned int numtoc=hdr->toc_alloc;
+  unsigned int numtocused=hdr->toc_size;
+  unsigned int *toc=hdr->toc;
+  unsigned int *toc_ex=hdr->toc_ex;
+  unsigned int numtocused2=(toc_ex && hdr->toc_alloc > hdr->toc_size*2) ? (hdr->toc_size + 1): 0;
+
+  while (numtoc--)
+  {
+    if (!numtocused) 
+    {
+      if (numtocused2)
+      {
+        if (--numtocused2 == hdr->toc_size) // signal extended TOC :)
+          bs.putbits(32,NSV_MAKETYPE('T','O','C','2'));
+        else
+          bs.putbits(32,*toc_ex++);
+      }
+      else // extra (unused by this implementation but could be used someday so we fill it with 0xFF) space
+        bs.putbits(32,~0);
+    }
+    else if (toc) 
+    {
+      bs.putbits(32,*toc++);
+      numtocused--;
+    }
+    else bs.putbits(32,0);
+  }
+  
+  unsigned int x;
+  for (x = hdr->header_size; x < padto; x ++) bs.putbits(8,0);
+}
+
+
+int nsv_readheader(nsv_InBS &bs, nsv_fileHeader *hdr)
+{
+  int s=0;
+  hdr->metadata=(void*)NULL;
+  hdr->toc=(unsigned int *)NULL;
+  hdr->toc_ex=(unsigned int *)NULL;
+  hdr->header_size=0;
+  hdr->file_lenbytes=~0;
+  hdr->file_lenms=~0;
+  hdr->toc_alloc=0;
+  hdr->toc_size=0;
+  hdr->metadata_len=0;
+  
+  if (bs.avail()<64) {
+	  return 8- (int)(bs.avail()/8);
+  }
+  s+=32;
+  if (bs.getbits(32) != NSV_HDR_DWORD) 
+  {
+    bs.seek(-s);
+    return -1;
+  }else{
+	  glCounterNSVf++;
+  }
+  s+=32;
+  unsigned int headersize=bs.getbits(32);
+
+	if (headersize >= 0x20000000)
+	{
+		bs.seek(-s);
+		return -1;
+	}
+  if ((unsigned int)bs.avail() < (headersize-4)*8)
+  {
+    int l=headersize-4- (int)(bs.avail()/8);
+    bs.seek(-s);
+    return l;
+  }
+
+  s+=32;
+  unsigned int lenbytes=bs.getbits(32);
+  s+=32;
+  unsigned int lenms=bs.getbits(32);
+  s+=32;
+  unsigned int metadatalen=bs.getbits(32);
+  s+=32;
+  unsigned int tocalloc=bs.getbits(32);
+  s+=32;
+  unsigned int tocsize=bs.getbits(32);
+
+  if (tocalloc < tocsize || lenbytes < headersize || tocalloc + metadatalen + s/8 > headersize)
+  {
+    bs.seek(-s);
+    return -1;
+  }
+
+  void *metadata=NULL;
+
+  if (metadatalen)
+  {
+		if (metadatalen > (SIZE_MAX/8))
+		{
+			bs.seek(-s);
+			return -1;
+		}
+    metadata=malloc(metadatalen+1);
+    if (!metadata) 
+    {
+      bs.seek(-s);
+      return -1;
+    }
+    s+=metadatalen*8;
+    bs.getdata(metadatalen*8,metadata);
+    ((char*)metadata)[metadatalen]=0;
+  }
+
+  unsigned int *toc=NULL;
+  unsigned int *toc_ex=NULL;
+
+  if (tocalloc && tocsize < (SIZE_MAX/8))
+  {
+    toc=(unsigned int *)malloc(tocsize * 4 * 2);
+    if (!toc) 
+    {
+      free(metadata);
+      bs.seek(-s);
+      return -1;
+    }
+    unsigned int x;
+    int bitsread=0;
+    for (x = 0; x < tocsize; x ++) { toc[x] = bs.getbits(32); bitsread += 32; }
+
+    if (tocalloc > tocsize*2)
+    {
+      bitsread += 32;
+      if (bs.getbits(32) == NSV_MAKETYPE('T','O','C','2'))
+      {
+        toc_ex=toc + tocsize;
+        for (x = 0; x < tocsize; x ++) { toc_ex[x] = bs.getbits(32); bitsread += 32; }
+      }
+    }
+    bs.seek((tocalloc-tocsize)*32 - bitsread);
+    s+=tocalloc*32;
+  }
+
+  hdr->header_size=headersize;
+  if (lenbytes == 0xFFFFFFFF)
+		hdr->file_lenbytes=lenbytes;
+  else
+		hdr->file_lenbytes=lenbytes-headersize;
+  hdr->file_lenms=lenms;
+  hdr->metadata=metadata;
+  hdr->metadata_len=metadatalen;
+  hdr->toc=toc;
+  hdr->toc_ex=toc_ex;
+  hdr->toc_alloc=tocalloc;
+  hdr->toc_size=tocsize;
+  
+  return 0;
+}
+
+char *nsv_getmetadata(void *metadata, char *name)
+{
+  if (!metadata) return NULL;
+  char *p=(char*)metadata;
+  size_t ln=strlen(name);
+  for (;;)
+  {
+    while (p && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++;
+    if (p || !*p) break;
+    if (!_strnicmp(p,name,ln) && p[ln]=='=' && p[ln+1] && p[ln+2])
+    {
+      int cnt=0;
+      char *np=p+ln+1;
+      char c=*np++;
+      while (np[cnt] && np[cnt] != c) cnt++;
+
+      char *s=(char*)malloc(cnt+1);
+      if (!s) return NULL;
+      memcpy(s,np,cnt);
+      s[cnt]=0;
+      return s;
+    }
+
+    // advance to next item
+    while (p && *p && *p != '=') p++;
+    if (!*p++) break;
+    if (!*p) break;
+    char c=*p++;
+    while (p && *p && *p != c) p++;
+    if (*p) p++;
+  }
+  return NULL;
+}
diff --git a/Src/nsv/nsvlib.h b/Src/nsv/nsvlib.h
new file mode 100644
index 00000000..b773d996
--- /dev/null
+++ b/Src/nsv/nsvlib.h
@@ -0,0 +1,364 @@
+/*
+** nsvlib.h - NSV file/bitstream reading/writing interface
+** 
+** Copyright (C) 2001-2002 Nullsoft, Inc.
+**
+** Confidential Subject to NDA
+*/
+
+#ifndef _NSVLIB_H_
+#define _NSVLIB_H_
+
+/*********************************************************************
+** bitstream classes 
+*/
+
+#include "nsvbs.h"
+
+
+/*********************************************************************
+** NSV packeting limits
+*/
+#define NSV_MAX_AUDIO_LEN 0x8000  // 32kb
+#define NSV_MAX_VIDEO_LEN 0x80000 // 512kb
+#define NSV_MAX_AUX_LEN   0x8000  // 32kb for each aux stream
+#define NSV_MAX_AUXSTREAMS 15     // 15 aux streams maximum
+
+
+/*********************************************************************
+** Constants for setting certain metadata items using addHdrMetaData()
+*/
+#define METADATANAME_AUTHOR			"Author"
+#define METADATANAME_TITLE			"Title"
+#define METADATANAME_COPYRIGHT		"Copyright"
+#define METADATANAME_COMMENT		"Comment"
+#define METADATANAME_PROFILE		"Profile"
+#define METADATANAME_FILEID			"File ID"
+
+/*********************************************************************
+** NSV type utility functions/macros
+*/
+
+/*
+** Use NSV_MAKETYPE() to quickly make NSV audio/video/aux types.
+** ex: NSV_MAKETYPE('R','G','B','A')
+*/
+#define NSV_MAKETYPE(A,B,C,D) ((A) | ((B)<<8) | ((C)<<16) | ((D)<<24))
+
+/*
+** These functions convert types to and from strings.
+*/
+
+/* nsv_type_to_string() converts an NSV type to a string.
+ * out must be at least 5 bytes long. If 't' is not a valid type, 
+ * then out will be set to an empty string
+ * ex: 
+ *   char out[5]; 
+ *   nsv_type_to_string(NSV_MAKETYPE('R','G','B','A'),out); 
+ *   strcmp(out,"RGBA") == 0
+ */
+void nsv_type_to_string(unsigned int t, char *out);
+
+/* nsv_string_to_type() converts a string to an NSV type. 
+ * Returns 0 if the type is not valid.
+ * ex: nsv_string_to_type("RGBA") == NSV_MAKETYPE('R','G','B','A')
+ */
+unsigned int nsv_string_to_type(char *in);
+
+
+/*********************************************************************
+** NSV bitstream packeting/unpacketing classes
+*/
+
+
+/* nsv_Packeter is used to packet audio/video/auxiliary data into
+ * a bitstream.
+ *
+ * ex:
+ *   nsv_Packeter p;
+ *   nsv_OutBS bs;
+ *   p.setVidFmt(NSV_MAKETYPE('R','G','B','A'),320,240,30.0);
+ *   p.setAudFmt(NSV_MAKETYPE('P','C','M',' '));
+ *   for (;;) {
+ *     doEncodeAudioAndVideo();
+ *     p.setSyncFrame(is_keyframe);
+ *     p.setSyncOffset(av_sync_offset);
+ *     p.setAudio(audio_data,audio_len);
+ *     p.setVideo(video_data,video_len);
+ *     p.clearAuxChannels(); // you can add aux channels if you want
+ *     if (p.packet(bs)) error();
+ *     int outbuflen;
+ *     void *outbuf=bs.get(&outbuflen);
+ *     fwrite(outbuf,outbuflen,1,fp); // write output
+ *     bs.clear(); // clear bitstream
+ *   }
+ *
+ */
+
+class nsv_Packeter {
+  public:
+    nsv_Packeter();
+    ~nsv_Packeter();
+
+    // init (per file) calls
+    void setVidFmt(unsigned int vfmt, unsigned int w, unsigned int h, double frt);
+    void setAudFmt(unsigned int afmt) { audfmt=afmt; }
+
+    // per frame calls
+    void setSyncFrame(int is_syncframe) { is_sync_frame=is_syncframe; }
+    void setSyncOffset(int syncoffs) { syncoffset_cur=syncoffs; }
+    void setAudio(void *a, int a_len) { audio=a; audio_len=a_len; }
+    void setVideo(void *v, int v_len) { video=v; video_len=v_len; }
+    int addAuxChannel(unsigned int fmt, void *data, int data_len) // 0 on success
+    {
+      if (aux_used >= NSV_MAX_AUXSTREAMS) return -1;
+      aux[aux_used]=data;
+      aux_len[aux_used]=data_len;
+      aux_types[aux_used]=fmt;
+      aux_used++;
+      return 0;
+    }
+    void clearAuxChannels() { aux_used=0; }
+
+    int packet(nsv_OutBS &bs); // returns 0 on success
+
+    // some utility getting functions
+    unsigned int getAudFmt() { return audfmt; }
+    unsigned int getVidFmt() { return vidfmt; }
+    unsigned int getWidth() { return width; }
+    unsigned int getHeight() { return height; }
+    double getFrameRate() { return framerate; }
+
+  private:
+    unsigned char framerate_idx;
+    unsigned int vidfmt;
+    unsigned int audfmt;
+    unsigned int width;
+    unsigned int height;
+    double framerate;
+    int syncoffset_cur;
+
+    int aux_used;
+    void *aux[NSV_MAX_AUXSTREAMS];
+    int aux_len[NSV_MAX_AUXSTREAMS];
+    unsigned int aux_types[NSV_MAX_AUXSTREAMS];
+    int is_sync_frame;
+    void *audio;
+    int audio_len;
+    void *video;
+    int video_len;
+};
+
+
+/* nsv_Unpacketer is used to unpacket a bitstream into audio/video/auxiliary data
+ * to decode, use an nsv_InBS object with data, and call unpacket().
+ * ex:
+ *  nsv_Unpacketer up;
+ *  nsv_InBS in;
+ *  nsv_InBS videoout, audioout;
+ *  up.setVideoOut(&videoout);
+ *  up.setAudioOut(&audioout);
+ *  for (;;) {
+ *    int ret=up.unpacket(in);
+ *    if (ret < 0) break; // eof
+ *    if (ret > 0) add_data_to_bitstream(&in,ret);
+ *    if (!ret) { // got frame
+ *      int vl=videoout.getbits(32);
+ *      int al=videoout.getbits(32);
+ *      char *vd=(char*)videoout.getcurbyteptr();
+ *      char *ad=(char*)audioout.getcurbyteptr();
+ *      doDecode(vd,vl,ad,al);
+ *      videoout.seek(vl*8);
+ *      audioout.seek(al*8);
+ *      videoout.compact(); // free memory up
+ *      audioout.compact(); // free memory up
+ *      in.compact(); // free memory up
+ *    }
+ *  }
+ */
+
+class nsv_Unpacketer {
+  public:
+    nsv_Unpacketer() { reset(); }
+    ~nsv_Unpacketer() { }
+
+    void reset(int full=1); // if full, full reset is done. 
+                            // if not, then it is a partial reset (ie for seeking)
+
+    // when EOF is set, the unpacketer will fail instead of requesting more data at the
+    // end; it will also not require that the next frame be available for sync
+    // (normally it looks ahead to verify data)
+    void setEof(int eof=1) { m_eof=eof; }
+    int getEof() { return m_eof; }
+
+    // use these to set where the unpacketer writes the output of each stream
+    // set to NULL to ignore output of that stream
+    
+    void setAudioOut(nsv_InBS *output=NULL) { m_audiobs=output; }
+    // the format of the audio data written to the output is:
+    //   32 bits: length of frame
+    //   ? bytes: audio data
+    // (to read):
+    //   int l=output->getbits(32);
+    //   decode_audio(output->getcurbyteptr(),l);
+    //   output->seek(l*8);
+
+
+    void setVideoOut(nsv_InBS *output=NULL) { m_videobs=output; }
+    // the format of the video data written to the output is:
+    //   32 bits: length of frame
+    //   ? bytes: video data
+    // (to read):
+    //   int l=output->getbits(32);
+    //   decode_video(output->getcurbyteptr(),l);
+    //   output->seek(l*8);
+
+    void setAuxOut(nsv_InBS *output=NULL) { m_auxbs=output; }
+    // the format of the aux data written to the output is:
+    //   32 bits: length of frame
+    //   32 bits: type of aux data
+    //   ? bytes: aux data
+    // (to read):
+    //   int l=output->getbits(32);
+    //   int type=output->getbits(32);
+    //   decode_aux(output->getcurbyteptr(),l);
+    //   output->seek(l*8);
+    // aux is different than audio/video in that it includes a 32 bit
+    // type value that is not included in the length.
+
+
+    // returns 0 on success, >0 on needs (at least X bytes) more data, 
+    // -1 on error (eof and no header found)
+    int unpacket(nsv_InBS &bs);
+
+
+    // do we have enough sync to determine formats/widths/heights/framerates
+    int isValid() { return valid; }
+    
+    // are we fully synched? 
+    int isSynched() { return synched; }
+
+    // get sync offset from when we first synched up
+    signed int getSyncOffset() { return (signed int) syncoffset; }
+
+    // get sync offset from current frame (not usually used)
+    signed int getCurSyncOffset() { return (signed int) syncoffset_cur; }
+
+    // get video, audio, width, height, framerate formats.
+    unsigned int getVidFmt() { return vidfmt; }
+    unsigned int getAudFmt() { return audfmt; }
+    unsigned int getWidth() { return width; }
+    unsigned int getHeight() { return height; }
+    double getFrameRate() { return framerate; }
+    unsigned char getFrameRateIdx() { return framerate_idx; }
+
+    // is current frame a sync frame?
+    int isSynchFrame() { return is_sync_frame; }
+
+  private:
+    nsv_InBS *m_audiobs, *m_videobs, *m_auxbs;
+    int valid; // contents of stream info are valid for syncing
+    int synched; // turns off anal packet checking
+    unsigned int vidfmt;
+    unsigned int audfmt;
+    unsigned int width;
+    unsigned int height;
+    double framerate;
+    int is_sync_frame;
+    unsigned char framerate_idx;
+    int syncoffset;
+    int syncoffset_cur;
+
+    int m_eof;
+};
+
+
+/*********************************************************************
+** NSV file header reading/writing functions
+*/
+
+
+typedef struct {
+  // header_size is the size of NSV header. nsv_writeheader() and nsv_readheader()
+  // will set this automatically
+  unsigned int header_size; 
+
+  // file_lenbytes is the size of the NSV bitstream (not including the header size)
+  // this can be 0xFFFFFFFF to signify unknown length
+  unsigned int file_lenbytes;
+
+  // file_lenms is the length of the NSV bitstream in milliseconds.
+  // this can be 0xFFFFFFFF to signify unknown length
+  unsigned int file_lenms;
+
+  // metadata_len describes the length of the metadata.
+  unsigned int metadata_len;
+
+  // toc_alloc describes the allocated length of the TOC (in entries).
+  // set this to zero to use toc_size (recommended).
+  unsigned int toc_alloc;
+
+  // toc_size describes the used size of the TOC (in entries)
+  // set this to zero to disable the TOC. When using toc_ex,
+  // this must be < toc_alloc/2 (if using nsv_writeheader, and
+  // toc_size is too big, toc_alloc will be grown automatically.
+  unsigned int toc_size;
+
+  // buffer which contains the TOC. this will be automatically 
+  // allocated when using nsv_readheader(), but you should allocate
+  // this yourself when using nsv_writeheader()
+  unsigned int *toc;
+
+  // if used, contains time pairs (in frames) for the offset. this will be 
+  // automatically allocated when using nsv_readheader(), but you should allocate
+  // this yourself when using nsv_writeheader()
+  // DO NOT FREE THIS VALUE IF IT WAS ALLOCATED FROM NSV_READHEADER. :)
+  // (it is just an extension of toc, which should be freed with free())
+  unsigned int *toc_ex;
+
+  // buffer which contains metadata. allocated when using nsv_readheader(), 
+  // but you should allocate this yourself when using nsv_writeheader()
+  // note that nsv_readheader() will NULL terminate this buffer.
+  void *metadata;
+
+} nsv_fileHeader;
+
+// nsv_writeheader() writes the NSV file header to the bitstream bs.
+// the NSV file header will be at LEAST padto bytes long (usually
+// you will leave padto to 0)
+void nsv_writeheader(nsv_OutBS &bs, nsv_fileHeader *hdr, unsigned int padto);
+
+// nsv_readheader() reads an NSV file header from a bitstream bs.
+// if the return value is less than zero, then there is no NSV
+// file header in bs. if the return value is zero, the NSV file
+// header was succesfully read. if the return value is positive,
+// then at least that many more bytes are needed to decode the
+// header.
+// ex:
+//   nsv_InBS bs;
+//   nsv_fileHeader hdr;
+//   for (;;) {
+//      int ret=nsv_readheader(bs,&hdr);
+//      if (ret<=0) break;
+//      addBytesToBs(bs,ret);
+//   }
+//   if (hdr.header_size) { we_got_valid_header(&hdr); }
+//
+
+int nsv_readheader(nsv_InBS &bs, nsv_fileHeader *hdr);
+
+
+// nsv_getmetadata() retrieves a metadata item from the metadata 
+// block. if that item is not found, NULL is returned.
+// Note that the value returned by nsv_getmetadata() has been
+// malloc()'d, and you must free() it when you are done.
+// ex:
+//   char *v=nsv_getmetadata(hdr.metadata,"TITLE");
+//   if (v) printf("title=%s\n",v);
+//   free(v);
+//
+
+char *nsv_getmetadata(void *metadata, char *name);
+
+
+#endif//_NSVLIB_H_
diff --git a/Src/nsv/nsvplay/IDataReader.h b/Src/nsv/nsvplay/IDataReader.h
new file mode 100644
index 00000000..1ae234bf
--- /dev/null
+++ b/Src/nsv/nsvplay/IDataReader.h
@@ -0,0 +1,21 @@
+#ifndef NULLSOFT_NSV_NSVPLAY_IDATAREADER_H
+#define NULLSOFT_NSV_NSVPLAY_IDATAREADER_H
+
+#include <stddef.h>
+#include <bfc/platform/types.h>
+
+class IDataReader 
+{
+public:
+	virtual ~IDataReader() { }
+	virtual size_t read(char *buf, size_t len)=0; // returns bytes read
+	virtual bool iseof()=0;
+	virtual char *geterror()=0;
+	virtual char *gettitle() { return 0; }
+	virtual char *getheader(char *header_name) { return 0; }
+	virtual bool canseek() { return 0; }
+	virtual int seek(uint64_t newpos) { return 1; }
+	virtual uint64_t getsize() { return ~0; }
+};
+
+#endif
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/about.h b/Src/nsv/nsvplay/about.h
new file mode 100644
index 00000000..a04e48d6
--- /dev/null
+++ b/Src/nsv/nsvplay/about.h
@@ -0,0 +1,661 @@
+#ifndef _ABOUT_H_
+#define _ABOUT_H_
+
+#include <math.h>
+
+
+#pragma warning(disable : 4731)
+
+static HWND about_hwnd;
+
+#ifndef NO_ABOUT_EGG
+
+#define BITMAP_W 100
+#define BITMAP_H 64
+static HDC m_hdc;
+static HBITMAP m_hbm;
+static char *m_dib;
+static char ge_fbuf[(BITMAP_H+1)*BITMAP_W+1];
+static int ge_tmp;
+#define M_NUM_FX 9
+static int m_effect;
+#define BLOBS_NPOINTS 8
+static int BLOBPOINTS[4*BLOBS_NPOINTS];
+static int fire_textcnt,fire_textpos;
+static char *fire_texts[]={
+  "nsvplay",
+  "Nullsoft 2003-8",
+  "",
+  "greets to",
+  "winamp forums",
+  "#nullsoft",
+  "britney spears",
+  "p.s.",
+  "DrO was here",
+  " <3",
+  "",
+};
+static HDC scrolldc;
+static HBITMAP scrollbitmap;
+static char *scrolldib;
+static const char scrolltext[]="nullsoft presents you nSVpLAY hidden part!  cracked by rOn   +5 trainer by deadbeef ";
+static int scrolloffs;
+static char *rototmp;
+
+#endif //NO_ABOUT_EGG
+
+static INT_PTR CALLBACK aboutProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) 
+{
+	switch (uMsg)
+	{
+ 		case WM_INITDIALOG:
+#ifndef NO_ABOUT_EGG
+		{
+			HBITMAP about_bmp = NULL;
+			m_effect=M_NUM_FX-1;
+
+			// try to use the localised image and then revert to the normal dll image
+			about_bmp = (HBITMAP)LoadImage((HINSTANCE)lParam,MAKEINTRESOURCE(IDB_BITMAP1),IMAGE_BITMAP,0,0,LR_SHARED);
+			if(about_bmp == NULL){
+				about_bmp = (HBITMAP)LoadImage(g_hInstance,MAKEINTRESOURCE(IDB_BITMAP1),IMAGE_BITMAP,0,0,LR_SHARED);
+			}
+
+			// set on control with id of -1 (0xFFFFFFFF) or 0xFFFF (not sure how/why this happened)
+			SendDlgItemMessage(hwndDlg,0xFFFF,STM_SETIMAGE,IMAGE_BITMAP,(LPARAM)about_bmp);
+			SendDlgItemMessage(hwndDlg,-1,STM_SETIMAGE,IMAGE_BITMAP,(LPARAM)about_bmp);
+		}
+#endif
+			SetDlgItemText(hwndDlg,IDC_VERSION,WNDMENU_CAPTION);
+			break;
+
+		case WM_COMMAND:
+			switch (LOWORD(wParam))
+			{
+				case IDCANCEL:
+				case IDOK:
+#ifndef MODAL_ABOUT
+					DestroyWindow(hwndDlg);
+#else
+					EndDialog(hwndDlg,1);
+#endif
+				return FALSE;
+			}
+			break;
+
+		case WM_DESTROY:
+			about_hwnd=NULL;
+#ifndef NO_ABOUT_EGG
+			if (m_hbm) DeleteObject(m_hbm);
+			if (m_hdc) DeleteDC(m_hdc);
+			if (scrollbitmap) DeleteObject(scrollbitmap);
+			if (scrolldc) DeleteDC(scrolldc);
+			m_hbm=0;
+			m_hdc=0;
+			scrollbitmap=0;
+			scrolldc=0;
+			if (rototmp) free(rototmp);
+			rototmp=NULL;
+#endif
+			break;
+#ifndef NO_ABOUT_EGG
+		case WM_LBUTTONDBLCLK :
+			//easter eggs :)
+			if (++m_effect >= M_NUM_FX) m_effect=1;
+
+			KillTimer(hwndDlg,0x1234);
+
+			if (m_hbm) DeleteObject(m_hbm);
+			if (m_hdc) DeleteDC(m_hdc);
+			if (scrollbitmap) DeleteObject(scrollbitmap);
+			if (scrolldc) DeleteDC(scrolldc);
+			scrollbitmap=0;
+			scrolldc=0;
+			if (rototmp) free(rototmp);
+			rototmp=NULL;
+
+			{
+				struct
+				{
+					BITMAPINFO bmi;
+					RGBQUAD more_bmiColors[256];
+					LPVOID data;
+				} m_bitmap;
+				m_hdc = CreateCompatibleDC(NULL);
+				m_bitmap.bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+				m_bitmap.bmi.bmiHeader.biPlanes = 1;
+				m_bitmap.bmi.bmiHeader.biBitCount = 8;
+				m_bitmap.bmi.bmiHeader.biCompression = BI_RGB;
+				m_bitmap.bmi.bmiHeader.biSizeImage = 0;
+				m_bitmap.bmi.bmiHeader.biClrUsed = 256;
+				m_bitmap.bmi.bmiHeader.biClrImportant = 256;
+				m_bitmap.bmi.bmiHeader.biWidth = BITMAP_W;
+				m_bitmap.bmi.bmiHeader.biHeight = -BITMAP_H;
+				m_bitmap.bmi.bmiHeader.biSizeImage = BITMAP_W*BITMAP_H;
+
+				memset(ge_fbuf,0,BITMAP_W*(BITMAP_H+1));
+				fire_textcnt=0;
+
+				if (m_effect < 3)
+				{
+					unsigned char *t=(unsigned char *)m_bitmap.bmi.bmiColors;
+					int x=255;
+					int adj=!!m_effect;
+					t[0]=t[1]=t[2]=0;
+					t+=4;
+					while (x)
+					{
+						if (m_effect == 2)
+						{
+							if (x > 128)
+							{
+								t[0]=0;
+								t[1]=((256-x)*2)/3;
+								t[2]=(256-x)*2;
+							}
+							else
+							{
+								t[0]=256-x*2;
+								t[1]=255/3 + ((256-x)*2)/3;
+								t[2]=255;
+							}
+						}
+						else
+						{
+							int a=x*2;
+							if (a>255) a=255;
+							t[0]=a;
+							t[2-adj]=a;
+							a+=a;
+							if (a > 255) a=255;
+							t[1+adj]=a;
+						}
+
+						t+=4; 
+						x--;
+					}
+				}
+
+				if(m_effect==0)
+				{
+					//sine scroll
+					struct
+					{
+						BITMAPINFO bmi;
+						RGBQUAD more_bmiColors[1];
+						LPVOID data;
+					} m_bitmap;
+					scrolldc = CreateCompatibleDC(NULL);
+					m_bitmap.bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+					m_bitmap.bmi.bmiHeader.biPlanes = 1;
+  					m_bitmap.bmi.bmiHeader.biBitCount = 8;
+					m_bitmap.bmi.bmiHeader.biCompression = BI_RGB;
+					m_bitmap.bmi.bmiHeader.biSizeImage = 0;
+					m_bitmap.bmi.bmiHeader.biClrUsed = 1;
+					m_bitmap.bmi.bmiHeader.biClrImportant = 1;
+					m_bitmap.bmi.bmiHeader.biWidth = 128;
+					m_bitmap.bmi.bmiHeader.biHeight = -32;
+					m_bitmap.bmi.bmiHeader.biSizeImage = 128*32;
+					scrollbitmap = CreateDIBSection(scrolldc,&m_bitmap.bmi,DIB_RGB_COLORS, &m_bitmap.data, NULL, 0);
+					SelectObject(scrolldc,scrollbitmap);
+					SetBkMode(scrolldc,TRANSPARENT);
+					scrolldib = (char *)m_bitmap.data;
+					scrolloffs = 0;
+				}
+
+				if (m_effect == 1)
+				{
+					int *t=BLOBPOINTS;
+					int a=BLOBS_NPOINTS;
+					while (a)
+					{
+						t[0]=(rand()&127) - 64;
+						t[2]=(rand()&127) - 64;
+						t[1]=t[3]=a;
+						t+=4;
+						a--;
+					}
+				}
+
+				if((m_effect >= 3 && m_effect <= 8)) //rotozooms
+				{
+					rototmp=(char *)malloc(65536+256);
+					//generate noise texture
+					memset(rototmp,0xd0,65536+256);
+					__asm
+					{
+						mov cx,0ffffh
+						xor ax,ax
+						xor ebx,ebx
+						xor dx,dx
+						mov edi,[rototmp]
+					TEXGEN:
+						mov	bx,cx
+						add	ax,cx
+						rol	ax,cl
+						mov	dh,al
+						sar	dh,5
+						adc	dl,dh
+						adc	dl,[edi+ebx+255]
+						shr	dl,1
+						mov	[edi+ebx],dl
+						not	bh
+						mov	[edi+ebx],dl
+						loop TEXGEN
+					}
+
+					if ((!!(GetAsyncKeyState(VK_SHIFT)&0x8000)) ^ (m_effect==5)) // secondary easter egg, hah!
+						for (int x = 0; x < 256*256; x ++) rototmp[x] = 0x40 + ((x^(x>>8)) & 0x1F);
+
+					rototmp[0]=rototmp[1];
+					rototmp[0xff00]=rototmp[0xff01];
+
+					//generate palette
+					unsigned char *t=((unsigned char *)(&m_bitmap.bmi.bmiColors[0x40]));
+					for(int i=0;i<0x20;i++) 
+					{
+						int r,g,b;
+						switch(m_effect)
+						{
+							case 3: r=i*4; g=i*5; b=i*8; break;
+							case 4: r=i*4; g=i*7; b=i*8; break;
+							case 5: r=i*8; g=i*2; b=i*2; break;
+							case 6: r=i*6; g=i*8; b=i*6; break;
+							case 7: r=i*8; g=i*6; b=i*8; break;
+							case 8: r=i*6; g=i*6; b=i*8; break;
+						}
+						t[0]=b;
+						t[1]=g;
+						t[2]=r;
+						t+=4;
+					}
+				}
+
+				m_hbm = CreateDIBSection(m_hdc,&m_bitmap.bmi,DIB_RGB_COLORS, &m_bitmap.data, NULL, 0);
+				SelectObject(m_hdc,m_hbm);
+				m_dib = (char *)m_bitmap.data;
+
+				SetTimer(hwndDlg,0x1234,35,NULL);
+			}
+			break;
+
+		case WM_TIMER:
+		{
+			int nomemcpy=0;
+			static float inc=0;
+			inc++;
+			if (m_effect == 0) // oldsk00l sine scroll
+			{
+				double blah=3.14/BITMAP_W;
+				double val1=1;
+				double val2=(BITMAP_H-16)/2;
+				static double vinc=0;
+				__asm
+				{
+					mov edi, offset ge_fbuf
+					mov ecx, BITMAP_W*BITMAP_H
+					xor eax, eax
+					rep stosb
+				}
+
+				for(int j=0;j<8;j++) {
+					for(int k=0;k<16;k++) {
+						int col=255-k*(256/16);
+						if(col<128) col=128+(128-col);
+						memset(ge_fbuf+(k+(int)((BITMAP_H-16)*(cos(vinc+(j*8)*3.14/50)+1)/2))*BITMAP_W,col,BITMAP_W);
+					}
+				}
+
+				__asm
+				{
+					mov edi, offset ge_fbuf
+					mov ecx, 0
+					mov esi, dword ptr [scrolldib]
+
+				SINELOOP:
+					mov [ge_tmp], ecx
+					fild dword ptr [ge_tmp]
+					fmul qword ptr [blah]
+					fadd qword ptr [vinc]
+					fcos
+					fadd qword ptr [val1]
+					fmul qword ptr [val2]
+					fistp dword ptr [ge_tmp]
+					mov eax, [ge_tmp]
+					mov ebx, eax
+
+					mov edx, BITMAP_W
+					mul edx
+
+					mov dh, bl
+					push ecx
+					mov ebx, 0
+					mov ecx, 16
+
+				SINELOOP2:
+					cmp byte ptr [esi+ebx],0
+					je SINECONT
+
+					mov dl,0ffh
+					sub dl,dh
+					sub dl,cl
+
+					mov [edi+eax], dl
+				SINECONT:
+					add eax, BITMAP_W
+					add ebx, 128
+					loop SINELOOP2
+
+					pop ecx
+
+		            inc esi
+				    inc edi
+
+					inc ecx
+					cmp ecx, BITMAP_W
+					jl SINELOOP
+
+					mov edi, [scrolldib]
+					mov esi, edi
+					inc esi
+					mov ebx, 32
+				SINESCROLL:
+					mov ecx, 127
+					rep movsb
+					inc edi
+					inc esi
+					dec ebx
+					jnz SINESCROLL
+				}
+				vinc+=0.2;
+				scrolloffs++;
+				if((scrolloffs&7)==7)
+				{
+					int o=scrolloffs/8;
+					if(!scrolltext[o]) scrolloffs=0;
+					else TextOutA(scrolldc,100,0,&scrolltext[o],1);
+				}
+			} 
+			else if (m_effect == 1) // blobs
+			{
+				int *blobptr=BLOBPOINTS;
+				int i=BLOBS_NPOINTS*2;
+				while (i--)
+				{
+					if (blobptr[0] > 0) blobptr[1]--;
+					else blobptr[1]++;
+
+					int a=blobptr[1];
+					if (rand()&1) a++;
+					else a--;
+					blobptr[0]+=a/8;
+
+					blobptr+=2;
+				}
+
+				int y=BITMAP_H;
+				unsigned char *p=(unsigned char *)ge_fbuf;
+				while (y--)
+				{
+					int x=BITMAP_W;
+					while (x--)
+					{
+						blobptr=BLOBPOINTS;
+						i=BLOBS_NPOINTS;
+						double sum=0.0;
+						while (i--)
+						{
+							double as=(x-(BITMAP_W/2)) - blobptr[0];
+							double bs=(y-(BITMAP_H/2)) - blobptr[2];
+							sum+=sqrt(as*as + bs*bs);
+							blobptr+=4;
+						}
+						sum *= 6.0/BLOBS_NPOINTS;
+						int a=(int)sum;
+						if (a > 0xff) a= 0xff;
+						*p++=a;
+					}
+				}
+			}
+			else if(m_effect==2) //gayfire
+			{
+				unsigned char *p=(unsigned char *)ge_fbuf;
+				int x;
+				unsigned char *t=p + BITMAP_W*BITMAP_H;
+				for (x = 0; x < BITMAP_W; x ++)
+				{
+					int a=*t - 10;
+					if ((rand()&0x7) == 7) a+=100;
+					if (a < 0) a=0;
+					else if (a > 192) a=192;
+					*t++=a;//rand()&0xf0;
+				}
+				int y;
+				for (y = 0; y < BITMAP_H; y ++)
+				{
+					*p++=p[0]/4 + p[BITMAP_W]/2 + p[BITMAP_W+1]/4;
+
+					for (x = 1; x < BITMAP_W-1; x ++)
+						*p++=p[0]/4 + p[BITMAP_W]/4 + p[BITMAP_W-1]/4 + p[BITMAP_W+1]/4;
+
+					*p++=p[0]/4 + p[BITMAP_W]/2 + p[BITMAP_W-1]/4;
+				}
+				if (fire_textcnt-- <= 0)
+				{
+					memcpy(m_dib,ge_fbuf,BITMAP_W*BITMAP_H);
+					SetBkMode(m_hdc,TRANSPARENT);
+					SetTextColor(m_hdc,RGB(255,255,255));
+					RECT r={0,0,BITMAP_W,BITMAP_H};
+					DrawTextA(m_hdc,fire_texts[fire_textpos%(sizeof(fire_texts)/sizeof(fire_texts[0]))],-1,&r,DT_CENTER|DT_VCENTER|DT_SINGLELINE);
+					if (fire_textcnt < -30)
+					{
+						memcpy(ge_fbuf,m_dib,BITMAP_W*BITMAP_H);
+						fire_textpos++;
+						fire_textcnt=30;
+					}
+					else nomemcpy=1;
+				}
+			}
+			else if (m_effect == 3) //rotozoom
+			{
+				char *p=ge_fbuf;
+				static float angle=0;
+				for(int j=-32;j<32;j++)
+					for(int i=-50;i<50;i++)
+					{
+						//rotozoom
+						double x=(i*cosf(angle)-j*sinf(angle))*(2+cosf(angle*1.4f));
+						double y=(i*sinf(angle)+j*cosf(angle))*(2+cosf(angle*1.4f));
+						//slime
+						x+=cos(angle*x)*4;
+						y+=sin(angle*y)*4;
+						int x2=(int)x & 0xff;
+						int y2=(int)y & 0xff;
+						*p++=rototmp[256*y2+x2];
+					}
+            
+				angle+=0.01f;
+			} 
+			else if (m_effect == 4) //rotozoom 2
+			{
+				char *p=ge_fbuf;
+				double angle=cos(inc*0.01f)*2;
+				for(int j=-32;j<32;j++)
+					for(int i=-50;i<50;i++)
+					{
+						//position
+						double x=i-cos(inc*0.013f)*64;
+						double y=j+sin(inc*0.013f)*64;
+
+						//slime
+						x+=cos((angle+i)*50)*cos(angle)*4;
+						y+=sin((angle+j)*50)*cos(angle)*4;
+
+						//rotozoom
+						double x3=(x*cos(angle)-y*sin(angle))*(2+cos(angle*1.4f));
+						double y3=(x*sin(angle)+y*cos(angle))*(2+cos(angle*1.4f));
+
+						int x2=(int)x3 & 0xff;
+						int y2=(int)y3 & 0xff;
+						*p++=rototmp[256*y2+x2];
+					}
+				} 
+				else if (m_effect == 5) //3d rotozoom
+				{
+					char *p=ge_fbuf;
+					static float angle=0;
+					const double b=50;
+					for(int j=-32;j<32;j++)
+						for(int i=-50;i<50;i++)
+						{
+							//rotozoom
+							double x=(i*cos(angle)+j*sin(angle));//*(2+cos(angle*1.4f));
+							double y=(i*sin(angle)-j*cos(angle));//*(2+cos(angle*1.4f));
+							//gay z-projection
+							x*=b/(((double)j+32));
+							y*=b/(((double)j+32));
+							//position
+							x-=cos(inc*0.013f)*64;
+							y+=sin(inc*0.013f)*64;
+              
+							int x2=(int)x & 0xff;
+							int y2=(int)y & 0xff;
+
+							char c=rototmp[256*y2+x2];
+							*p++=0x40+((c-0x40)*(j+32)/56);
+						}
+            
+					angle+=0.01f;
+					//b++;
+				} 
+				else if (m_effect == 6) //tunnel
+				{
+					const double TINYNUM=1.0E-6;
+					const double CONE_RADIUS=128;
+					const double FOV=120.0;
+					#define sqr(a) ((a)*(a))
+	    
+					char *p=ge_fbuf;
+					for(int y=-32;y<32;y++)
+						for(int x=-50;x<50;x++)
+						{
+							double originx=cos(inc*0.025f)*20;
+							double originy=sin(inc*0.04f)*20;
+							double originz=inc*4;
+							double dirx=x/FOV;
+							double diry=y/FOV;
+							double dirz=1;
+
+							//normalize dir vector
+							{
+  								double l=1.0f/sqrt(sqr(dirx)+sqr(diry)+sqr(dirz));
+								dirx*=l;
+								diry*=l;
+								dirz*=l;
+							}
+
+							//y-axis rotation
+							{
+								double rot=inc*0.015f;
+								double dirx2=dirx*cos(rot)+dirz*sin(rot);
+								dirz=dirx*sin(rot)-dirz*cos(rot);
+								dirx=dirx2;
+							}
+
+							//tunnel algo shit
+							double a=sqr(dirx)+sqr(diry);
+							double b=2*(originx*dirx + originy*diry);
+							double c=sqr(originx)+sqr(originy)-sqr(CONE_RADIUS);
+							double delta=sqrt(sqr(b)-(4*a*c));
+
+							double t1=(-b+delta)/(2*a+TINYNUM);
+							double t2=(-b-delta)/(2*a+TINYNUM);
+
+							double t=t1>0?t1:t2;
+
+							double intx=originx+dirx*t;
+							double inty=originy+diry*t;
+							double intz=originz+dirz*t;
+
+							//tex. coords
+							int u=(int)(fabs(intz)*0.6);
+							int v=(int)(fabs(atan2(inty,intx)*256/3.14159265));
+
+							//depth
+							t=20000.0/t;
+							int z=(int)(t>63?63:t);
+
+							u&=0xff;
+							v&=0xff;
+							z&=0xff;
+
+							{
+								char c=rototmp[256*u+v];
+								*p++=0x40+((c-0x40)*z/64);
+							}
+					}
+				} 
+				else if(m_effect==7) //washing machine
+				{
+					char *p=ge_fbuf;
+					for(int j=-32;j<32;j++)
+						for(int i=-50;i<50;i++)
+						{
+							double dist=sqrt(double(sqr(i)+sqr(j))); // pythagoras rules :)
+							double angle=cos(dist*0.05f)*(cos(inc*0.1f)) + inc*0.07f;
+							//rotozoom
+							double x=(i*cos(angle)-j*sin(angle));
+							double y=(i*sin(angle)+j*cos(angle));
+							int x2=(int)x & 0xff;
+							int y2=(int)y & 0xff;
+							*p++=rototmp[256*y2+x2];
+						}
+				}
+				else if(m_effect==8) //reflection-like(?) effect
+				{
+					char *p=ge_fbuf;
+					for(int j=-32;j<32;j++)
+						for(int i=-50;i<50;i++)
+						{
+							double dist=sqrt(double(sqr(i)+sqr(j)));
+							double zoom=cos(dist*0.05f)*(cos(inc*0.02f)*8)+1;
+							//rotozoom
+							double x=i*zoom+inc;
+							double y=j*zoom+inc;
+							int x2=(int)x & 0xff;
+							int y2=(int)y & 0xff;
+							*p++=rototmp[256*x2+y2];
+						}
+				}
+
+				if (!nomemcpy) memcpy(m_dib,ge_fbuf,BITMAP_W*BITMAP_H);
+				if (hwndDlg != NULL)
+				{
+					HDC h = GetDC(hwndDlg);
+					BitBlt(h, 11, 11, BITMAP_W, BITMAP_H, m_hdc, 0, 0, SRCCOPY);
+					ReleaseDC(hwndDlg, h);
+				}
+			}
+			break;
+#endif
+	}
+	return 0;
+}
+
+static void do_about(HWND hwnd, HINSTANCE hinst) {
+#ifndef MODAL_ABOUT
+	if(about_hwnd) {
+		SetForegroundWindow(about_hwnd);
+		return;
+	}
+	about_hwnd=CreateDialogParam((!hinst?g_hInstance:hinst),MAKEINTRESOURCE(IDD_ABOUT),hwnd,aboutProc,(LPARAM)hinst);
+	ShowWindow(about_hwnd,SW_SHOW);
+#else
+#ifdef LOC_MODAL_ABOUT
+	WASABI_API_DIALOGBOXPARAMW(IDD_ABOUT,hwnd,aboutProc,(LPARAM)hinst);
+#else
+	DialogBoxParam((!hinst?g_hInstance:hinst),MAKEINTRESOURCE(IDD_ABOUT),hwnd,aboutProc,(LPARAM)hinst);
+#endif
+#endif
+}
+
+#endif//_ABOUT_H_
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/audiostub.cpp b/Src/nsv/nsvplay/audiostub.cpp
new file mode 100644
index 00000000..83794693
--- /dev/null
+++ b/Src/nsv/nsvplay/audiostub.cpp
@@ -0,0 +1,575 @@
+#include <windows.h>
+#include "audiostub.h"
+
+#define CAPTION "NSV Player Sound Output Error"
+#define MAX(x,y) (( y ) < ( x ) ? ( x ) : ( y ))
+#define MIN(x,y) (( x ) < ( y ) ? ( x ) : ( y ))
+
+#define S_MINSIZE (1<<28)
+#define MAX_NUM_BLOCKS 8
+
+#define NUM_BLOCKS 8
+#define BUFSIZE_MS 1500
+
+#define BLOCKSIZE_MAX 32768
+#define BLOCKSIZE_MIN 8192
+
+int g_audio_use_mixer=0;
+
+class PCM_AudioOut : public IAudioOutput 
+{
+  public:
+    PCM_AudioOut(int samplerate, int numchannels, int bitspersamp);
+    ~PCM_AudioOut();
+
+    int canwrite(); // returns bytes writeable
+    void write(void *_buf, int len);
+    unsigned int getpos();
+    unsigned int getwritepos();
+    void flush(unsigned int time_ms);
+    void pause(int pause);
+    int isplaying(void);
+    void setvolume(int volume);
+    void setpan(int pan);
+
+    int open_success() { return init; }
+    void getdescstr(char *buf)
+    {
+      *buf=0;
+      if (g_srate && g_nch) wsprintf(buf,"%dkHz %s",g_srate/1000,g_nch==2?"stereo":"mono");
+    }
+
+  private:
+    DWORD ThreadP();
+
+    void _setvol(void);
+
+    static DWORD WINAPI _threadproc(LPVOID p);
+    static void CALLBACK cbFunc(HWAVEOUT hwo,UINT uMsg,DWORD dwInstance,DWORD dwParam1,DWORD dwParam2)
+    {
+	    if (uMsg == WOM_DONE) { ReleaseSemaphore((HANDLE)dwInstance,1,NULL);}
+    }
+    void do_set_blocksizes(void);
+    void do_samples_altvol(char *in, int blen);
+
+    int init;
+
+    int min_blocksize;
+    int max_blocksize;
+
+    int ispcnt;
+    int num_blocks;
+
+    char            *g_buffer, *g_buffer_write, *g_buffer_read;
+    int              g_buffer_length, g_buffer_valid,g_buffer_inlength;
+    HWAVEOUT         g_hWaveOut;
+    WAVEHDR          g_wave_headers[MAX_NUM_BLOCKS];
+    int				g_bps,g_nch,g_srate;
+    volatile int		g_pause, g_wavecnt, g_prebuf,g_writeall, g_quit_flag,g_writetime_bytes, g_outtime_bytes, g_outtime_interp;
+
+    HANDLE           g_hSem,g_hEvent, g_hThread;
+    CRITICAL_SECTION g_cs;
+
+    int              g_bytes_per_sec;
+    int a_v,a_p;
+
+    unsigned char *g_vol_table;
+};
+
+
+PCM_AudioOut::PCM_AudioOut(int samplerate, int numchannels, int bitspersamp)
+{
+  init=0;
+  a_v=255;
+  a_p=0;
+  num_blocks=0;
+
+  g_buffer_valid=g_buffer_inlength=0;
+  g_hWaveOut=NULL;
+  memset(g_wave_headers,0,sizeof(g_wave_headers));
+
+  g_hSem=g_hEvent=g_hThread=0;
+
+	int x;
+	DWORD id;
+	MMRESULT res;
+	WAVEFORMATEX wfx={WAVE_FORMAT_PCM,numchannels,samplerate,samplerate*numchannels*(bitspersamp/8),
+		numchannels*(bitspersamp/8),bitspersamp};
+	
+	g_bps=bitspersamp;
+	g_nch=numchannels;
+  g_srate=samplerate;
+	g_bytes_per_sec=wfx.nAvgBytesPerSec;
+
+  {
+    char *p=(char*)g_wave_headers;
+    int n=sizeof(g_wave_headers);
+    while (n--) *p++=0;
+  }
+	g_buffer_length = MulDiv(g_bytes_per_sec, BUFSIZE_MS, 1000);
+	g_buffer_length &= ~1023;
+	if (g_buffer_length < 4096) g_buffer_length=4096;
+
+	g_buffer=(char *)GlobalAlloc(GMEM_FIXED,g_buffer_length+min(65536,g_buffer_length));
+	if (g_buffer == NULL)
+	{
+		MessageBox(NULL,"Error allocating buffer", CAPTION,MB_OK|MB_ICONSTOP);
+		return;
+	}
+
+	g_prebuf=g_buffer_length/4;
+	g_buffer_read=g_buffer_write=g_buffer;
+	g_wavecnt=g_pause=g_writeall=g_buffer_valid=g_writetime_bytes=g_outtime_bytes=g_buffer_inlength=0;
+	g_quit_flag=0;
+	
+  g_vol_table=NULL;
+
+	do_set_blocksizes();
+
+	g_hSem=CreateSemaphore(NULL,0,256,NULL);
+	for (x = 0; (res=waveOutOpen(&g_hWaveOut,WAVE_MAPPER,&wfx,(DWORD)cbFunc,(DWORD)g_hSem,CALLBACK_FUNCTION))==MMSYSERR_ALLOCATED && x<10; x ++)
+		Sleep(100);
+	if (res != MMSYSERR_NOERROR)
+	{
+		char t[512];
+		waveOutGetErrorText(res,t,sizeof(t));
+		MessageBox(NULL,t, CAPTION,MB_OK|MB_ICONSTOP);
+		GlobalFree((HGLOBAL) g_buffer);
+		CloseHandle(g_hSem);
+		g_buffer = NULL;
+		return;
+	}
+
+  ispcnt=0;
+	g_outtime_interp=GetTickCount();
+	g_hEvent=CreateEvent(NULL,FALSE,FALSE,NULL);
+	InitializeCriticalSection(&g_cs);
+
+	g_hThread=CreateThread(NULL,0,_threadproc,(void*)this,0,&id);
+  SetThreadPriority(g_hThread,THREAD_PRIORITY_HIGHEST);
+
+  init=1;
+}
+
+
+void PCM_AudioOut::do_set_blocksizes(void)
+{
+	int t,t2,t4;
+	t=(MulDiv(BLOCKSIZE_MIN,g_bytes_per_sec,44100)+1023)&~1023;
+	if (t<1024) t=1024;
+	if (t>32768) t=32768;
+
+	t2=(MulDiv(BLOCKSIZE_MAX,g_bytes_per_sec,44100*4)+1023)&~1023;
+	if (t2 < t) t2 = t;
+	if (t2 > 65536) t2=65536;
+
+	t4 = NUM_BLOCKS;
+
+	num_blocks=t4;
+	max_blocksize=t2;
+	min_blocksize=t;
+}
+
+
+PCM_AudioOut::~PCM_AudioOut(void)
+{
+  if (init)
+  {
+	  int x;
+	  g_quit_flag=1;
+	  SetEvent(g_hEvent);
+	  while (g_quit_flag == 1) Sleep(70);
+
+	  waveOutReset(g_hWaveOut);
+
+	  for (x = 0; x < MAX_NUM_BLOCKS; x++)
+		  if (g_wave_headers[x].dwFlags & WHDR_PREPARED)
+			  waveOutUnprepareHeader(g_hWaveOut,&g_wave_headers[x],sizeof(g_wave_headers[0]));
+	  if (waveOutClose(g_hWaveOut) != MMSYSERR_NOERROR)
+	  {
+		  MessageBox(NULL,"Error closing sound device.",CAPTION,MB_OK);
+	  }
+	  if (g_buffer) GlobalFree((HGLOBAL) g_buffer);
+	  DeleteCriticalSection(&g_cs);
+	  CloseHandle(g_hThread);
+	  CloseHandle(g_hSem);
+	  CloseHandle(g_hEvent);
+
+    if(g_vol_table) GlobalFree((HGLOBAL)g_vol_table);
+  }
+}
+
+void PCM_AudioOut::write(void *_buf, int len)
+{
+  char *buf=(char *)_buf;
+	int l2;
+	if (len > 8192) len=8192;
+	l2=(g_buffer_write+len)-(g_buffer+g_buffer_length);
+	if (len <= 0 || !buf)
+	{
+		g_writeall=1;
+    //g_prebuf=0;
+		SetEvent(g_hEvent);
+		return;
+	}
+  ispcnt=0;
+	g_writeall=0;
+	if (l2 > 0)
+	{
+		int l1=len-l2;
+		memcpy(g_buffer_write,buf,l1);
+		memcpy(g_buffer,buf+l1,l2);
+		g_buffer_write=g_buffer+l2;
+	}
+	else
+	{
+		memcpy(g_buffer_write,buf,len);
+		g_buffer_write += len;
+		if (g_buffer_write == g_buffer+g_buffer_length) g_buffer_write=g_buffer;
+	}
+
+	EnterCriticalSection(&g_cs);
+	g_buffer_valid+=len;
+	LeaveCriticalSection(&g_cs);
+	g_writetime_bytes+=len;
+	if (g_wavecnt < num_blocks) 
+	{
+		SetEvent(g_hEvent);
+	}
+	return;
+}
+
+int PCM_AudioOut::canwrite(void)
+{
+	int t=(g_buffer_length-g_buffer_valid);
+	if (g_wavecnt==0) 
+	{
+		SetEvent(g_hEvent);
+	}
+  if (t>8192) t=8192;  // RG: since write() caps the # of bytes at 8192, this should reflect that!  otherwise, if we call write() with too many bytes, it throws the extra away and we'll never know it.
+	return t;
+}
+
+int PCM_AudioOut::isplaying(void)
+{
+	if (g_wavecnt==0) 
+	{
+		SetEvent(g_hEvent);
+	}
+  if (ispcnt < 7) ispcnt++;
+  if (g_buffer_valid < MIN(g_buffer_length/2,min_blocksize) && ispcnt==7) 
+  {
+    g_writeall=1;
+    g_prebuf=0;
+  }
+	return (g_wavecnt>0) || (g_buffer_valid>0);
+}
+
+void PCM_AudioOut::pause(int pause)
+{
+	if (g_hWaveOut)
+	{
+		int lastp=g_pause;
+		g_pause=pause;
+		if (pause == lastp) return;
+		if (g_pause)
+			waveOutPause(g_hWaveOut);
+		else
+		{
+			waveOutRestart(g_hWaveOut);
+			g_outtime_interp=GetTickCount();
+			SetEvent(g_hEvent);
+		}
+	}
+}
+
+void PCM_AudioOut::_setvol(void)
+{
+	DWORD vol, vo2, gv;
+	if (g_hWaveOut)
+	{
+		a_v=MIN(255,MAX(a_v,0));
+		a_p=MIN(127,MAX(a_p,-127));
+
+		vo2 = vol = (a_v*65535) / 255;
+
+		if (a_p > 0)
+		{
+			vol *= (127-a_p);
+			vol /= 127;
+		}
+		else if (a_p < 0)
+		{
+			vo2 *= (127+a_p);
+			vo2 /= 127;
+		}
+		gv=vol|(vo2<<16);
+    if(g_audio_use_mixer) {
+      if(g_vol_table) {
+        EnterCriticalSection(&g_cs);
+        GlobalFree((HGLOBAL)g_vol_table);
+        g_vol_table=NULL;
+        LeaveCriticalSection(&g_cs);
+      }
+      waveOutSetVolume(g_hWaveOut,gv);
+    } else {
+      EnterCriticalSection(&g_cs);
+      if(!g_vol_table) {
+        int l=(g_bps==8)?512:(4*32769);
+				g_vol_table=(unsigned char *)GlobalAlloc(GPTR,l);
+      }
+      //compute volume lookup table
+      int x;
+      if (g_bps==8) {
+			  if (g_nch==1) for (x = 0; x < 256; x ++) g_vol_table[x] = (x*a_v)/256;
+				else for (x = 0; x < 256; x ++)
+				{
+					g_vol_table[x]     = (x*(int)vol)/65536;
+					g_vol_table[x+256] = (x*(int)vo2)/65536;
+				}
+      } else {
+				short *vol_tab16 = (short *)g_vol_table;
+				if (g_nch==1) for (x = 0; x < 32769; x ++) vol_tab16[x] = -(x*a_v)/256;
+				else for (x = 0; x < 32769; x ++)
+				{
+					vol_tab16[x]       = -(x*(int)vol)/65536;
+					vol_tab16[x+32769] = -(x*(int)vo2)/65536;
+				}
+			}
+      LeaveCriticalSection(&g_cs);
+    }
+	}
+}
+
+
+void PCM_AudioOut::flush(unsigned int time_ms)
+{
+	int x;
+	EnterCriticalSection(&g_cs);
+	g_outtime_bytes=g_writetime_bytes=MulDiv(time_ms,g_bytes_per_sec,1000);
+	waveOutReset(g_hWaveOut);
+	for (x = 0; x < MAX_NUM_BLOCKS; x++)
+		if ((g_wave_headers[x].dwFlags & WHDR_PREPARED))
+		{
+			waveOutUnprepareHeader(g_hWaveOut,&g_wave_headers[x],sizeof(g_wave_headers[0]));
+			g_wave_headers[x].dwFlags =0;
+		}
+	while (WaitForSingleObject(g_hSem,0)==WAIT_OBJECT_0);
+	g_prebuf=g_buffer_length/8;
+	g_buffer_read=g_buffer_write=g_buffer;
+	g_writeall=g_wavecnt=g_buffer_valid=g_buffer_inlength=0;
+  ispcnt=0;
+	LeaveCriticalSection(&g_cs);
+}
+
+unsigned int PCM_AudioOut::getwritepos(void)
+{
+  return MulDiv(g_writetime_bytes,1000,g_bytes_per_sec);
+}
+
+unsigned int PCM_AudioOut::getpos(void)
+{
+	unsigned int t;
+	if (!g_pause) 
+	{
+		t=GetTickCount()-g_outtime_interp;
+		if (t > 1000) t=1000;
+	}
+	else t=0;
+	return t+MulDiv(g_outtime_bytes,1000,g_bytes_per_sec);
+}
+
+DWORD WINAPI PCM_AudioOut::_threadproc(LPVOID p)
+{
+  return ((PCM_AudioOut *)p)->ThreadP();
+}
+
+DWORD PCM_AudioOut::ThreadP()
+{
+	HANDLE hs[2]={g_hSem,g_hEvent};
+	while (1) 
+	{
+		int i;
+		i=WaitForMultipleObjects(2,hs,FALSE,INFINITE);
+		if (g_quit_flag) break;
+		if (i == WAIT_OBJECT_0)
+		{
+			int x;
+			for (x = 0; x < MAX_NUM_BLOCKS && !(g_wave_headers[x].dwFlags & WHDR_DONE); x++);
+			if (x < MAX_NUM_BLOCKS) 
+			{
+				EnterCriticalSection(&g_cs);
+				if (g_wave_headers[x].dwFlags & WHDR_DONE)
+				{
+					int r=g_wave_headers[x].dwBufferLength;
+					g_outtime_interp=GetTickCount();
+					g_buffer_valid   -=r;
+					g_buffer_inlength-=r;
+					g_outtime_bytes  +=r;
+					waveOutUnprepareHeader(g_hWaveOut,&g_wave_headers[x],sizeof(g_wave_headers[0]));
+					g_wave_headers[x].dwFlags=0;
+					g_wavecnt--;
+					i++;
+				}
+				LeaveCriticalSection(&g_cs);
+			}
+		}
+		if (i == WAIT_OBJECT_0+1 && !g_pause)
+		{
+			int l;
+			int m;
+			int t=num_blocks;
+			EnterCriticalSection(&g_cs);
+			l=g_buffer_valid-g_buffer_inlength;
+			LeaveCriticalSection(&g_cs);
+		again:
+			if (g_quit_flag) break;
+			if (g_writeall && l<max_blocksize) 
+      {
+        ispcnt=0;
+        g_writeall=0;
+        m=1;
+      }
+			else
+			{
+				m=MAX(MIN(g_buffer_length/2,min_blocksize),g_prebuf);
+				l&=~1023;
+			}
+			if (l >= m && g_wavecnt < t)
+			{
+				int x;
+				if (l > max_blocksize) l=max_blocksize;
+				for (x = 0; x < t && (g_wave_headers[x].dwFlags & WHDR_PREPARED); x++);
+				if (x < t)
+				{
+					int ml=(g_buffer+g_buffer_length)-g_buffer_read;
+          if (l > g_buffer_length) l=g_buffer_length;
+					if (l>ml) 
+          {
+            int addlen=l-ml;
+            if (addlen > 65536) addlen=65536;
+            if (addlen > g_buffer_length) addlen=g_buffer_length;
+            memcpy(g_buffer+g_buffer_length,g_buffer,addlen);
+          }
+
+					g_wave_headers[x].dwBufferLength=l;
+					g_wave_headers[x].lpData=g_buffer_read;
+
+          if (waveOutPrepareHeader(g_hWaveOut,&g_wave_headers[x],sizeof(g_wave_headers[0])) == MMSYSERR_NOERROR)
+					{
+            do_samples_altvol(g_wave_headers[x].lpData,g_wave_headers[x].dwBufferLength);
+
+						if (waveOutWrite(g_hWaveOut,&g_wave_headers[x],sizeof(g_wave_headers[0])) == MMSYSERR_NOERROR)
+						{
+							g_prebuf=0;
+
+							g_wavecnt++;
+
+							g_buffer_inlength += l;
+							g_buffer_read += l;
+							
+							if (g_buffer_read >= g_buffer+g_buffer_length) g_buffer_read-=g_buffer_length;
+
+							if (g_wavecnt < t)
+							{
+								EnterCriticalSection(&g_cs);
+								l=g_buffer_valid-g_buffer_inlength;
+								LeaveCriticalSection(&g_cs);
+								if (l >= m) goto again;
+							}
+						}
+						else 
+						{
+							waveOutUnprepareHeader(g_hWaveOut,&g_wave_headers[x],sizeof(g_wave_headers[0]));
+							g_wave_headers[x].dwFlags=0;
+						}
+					}
+					else g_wave_headers[x].dwFlags=0;
+				}
+			} 
+		}
+	}
+	g_quit_flag=2;
+	return 0;
+}
+
+void PCM_AudioOut::do_samples_altvol(char *in, int blen)
+{
+	if ((a_v != 255 || a_p) && g_vol_table) 
+	{
+		EnterCriticalSection(&g_cs);
+	  if (g_bps == 8) 
+		{
+			unsigned char *i=(unsigned char *)in;
+			int x = blen;
+			if (g_nch==1)
+			{
+				while (x--)	{ *i = g_vol_table[*i]; i ++; }
+			}
+			else
+			{
+				x>>=1;
+				while (x--)
+				{
+					i[0] = g_vol_table[i[0]];
+					i[1] = g_vol_table[i[1] + 256];
+					i+=2;
+				}
+			}
+		}
+		else if (g_bps == 16) 
+		{
+			short *i = (short *) in;
+			short *tab= (short *)g_vol_table;
+			int x = blen>>1;
+			if (g_nch==1)
+			{
+				while (x--)
+				{
+					int a = i[0];
+					if (a <= 0)	i[0] = tab[-a];
+					else i[0] = -tab[a];
+					i++;
+				}
+			}
+			else
+			{
+				x>>=1;
+				while (x--)
+				{
+					int a = i[0];
+					if (a <= 0)	i[0] = tab[-a];
+					else i[0] = -tab[a];
+					a=i[1];
+					if (a <= 0)	i[1] = tab[32769-a];
+					else i[1] = -tab[32769+a];
+					i+=2;
+				}
+			}
+		}
+	  LeaveCriticalSection(&g_cs);
+	}
+}
+
+void PCM_AudioOut::setvolume(int volume)
+{
+	if (volume >= 0 && volume <= 255) a_v=volume;
+	_setvol();
+}
+
+void PCM_AudioOut::setpan(int pan)
+{
+	if (pan >= -255 && pan <= 255) a_p=pan;
+	_setvol();
+}
+
+
+IAudioOutput *PCMOUT_CREATE(unsigned int outfmt[8])
+{
+  if (outfmt[0] != NSV_MAKETYPE('P','C','M',' ') ||
+      !outfmt[1] || !outfmt[2] || !outfmt[3]) return NULL;
+  PCM_AudioOut *p=new PCM_AudioOut(outfmt[1],outfmt[2],outfmt[3]);
+  if (p->open_success()) return p;
+  delete p;
+  return NULL;
+}
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/audiostub.h b/Src/nsv/nsvplay/audiostub.h
new file mode 100644
index 00000000..df9833fd
--- /dev/null
+++ b/Src/nsv/nsvplay/audiostub.h
@@ -0,0 +1,8 @@
+#ifndef _AUDIOSTUB_H_
+#define _AUDIOSTUB_H_
+
+#include "../dec_if.h"
+
+IAudioOutput *PCMOUT_CREATE(unsigned int outfmt[8]);
+
+#endif
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/decoders.cpp b/Src/nsv/nsvplay/decoders.cpp
new file mode 100644
index 00000000..82cba2bd
--- /dev/null
+++ b/Src/nsv/nsvplay/decoders.cpp
@@ -0,0 +1,675 @@
+#include <windows.h>
+#include "api.h"
+#include "main.h"
+#include "vfw.h"
+#include <api/service/services.h>
+#include "../nsv/svc_nsvFactory.h"
+#include <api/service/waservicefactory.h>
+#include "../../Winamp/in2.h"
+extern In_Module mod;
+
+// you should probably override these in your project settings
+
+// builtin decoders
+//#define BUILTIN_MP3_SUPPORT
+//#define BUILTIN_VP3_SUPPORT
+//#define BUILTIN_DIVX_SUPPORT
+//#define BUILTIN_PCM_SUPPORT
+//#define BUILTIN_VFW_SUPPORT
+
+// support dll decoders?
+//#define DLL_DECODER_SUPPORT
+
+//#define DLL_DECODER_SUPPORT_NOCURDIR
+
+#ifdef WINAMP_PLUGIN
+#  ifndef DLL_DECODER_SUPPORT
+#    define DLL_DECODER_SUPPORT
+#  endif
+#  ifndef DLL_DECODER_SUPPORT_NOCURDIR
+#    define DLL_DECODER_SUPPORT_NOCURDIR
+#  endif
+#  ifndef DLL_DECODER_SUPPORT_IN_
+#    define DLL_DECODER_SUPPORT_IN_
+#  endif
+#  ifndef BUILTIN_PCM_SUPPORT
+#    define BUILTIN_PCM_SUPPORT
+#  endif
+#endif
+
+#ifdef BUILTIN_VP3_SUPPORT
+#include "vp3stub.h"
+#endif
+#ifdef BUILTIN_VP5_SUPPORT
+#include "vp5stub.h"
+#endif
+#ifdef BUILTIN_MP3_SUPPORT
+#include "mp3stub.h"
+#endif
+
+#ifdef BUILTIN_VFW_SUPPORT
+
+class Gen_Decoder : public IVideoDecoder {
+  public:
+    Gen_Decoder(int w, int h);
+    ~Gen_Decoder();
+    int decode(int need_kf, 
+            void *in, int in_len, 
+            void **out, // out is set to a pointer to data
+            unsigned int *out_type, // 'Y','V','1','2' is currently defined
+            int *is_kf);
+    void flush() { }
+
+    int m_err;
+
+    int width,height;
+	  BITMAPINFO gen_bmo,gen_bmi;
+	  HIC gen_hic;  
+    unsigned char *vidbufdec;
+};
+
+Gen_Decoder::Gen_Decoder(int w, int h)
+{
+  width=w;
+  height=h;
+  m_err=0;
+  gen_hic=0;
+  vidbufdec=(unsigned char*)malloc(sizeof(YV12_PLANES) + w*h*3/2);
+}
+
+Gen_Decoder::~Gen_Decoder()
+{
+  if (gen_hic)
+  {
+    ICDecompressEnd(gen_hic);
+  	ICClose(gen_hic);
+  }
+  free(vidbufdec);
+}
+
+
+int Gen_Decoder::decode(int need_kf, 
+        void *in, int in_len, 
+        void **out, // out is set to a pointer to data
+        unsigned int *out_type, // 'Y','V','1','2' is currently defined
+        int *is_kf)
+{
+  *out_type=NSV_MAKETYPE('Y','V','1','2');
+  gen_bmi.bmiHeader.biSizeImage = in_len;
+  if(ICERR_OK == ICDecompress(gen_hic,0,(BITMAPINFOHEADER *) &gen_bmi, (char*)in,(BITMAPINFOHEADER *) &gen_bmo, (char*)vidbufdec+sizeof(YV12_PLANES)))
+  {
+    //*is_kf=!(!in_len || ((unsigned char *)in)[0] > 0x7f);
+    *is_kf=1;
+
+    if (need_kf && !*is_kf) 
+    {
+      return 0;
+    }
+    YV12_PLANES *image_vbd=(YV12_PLANES *)vidbufdec;
+    image_vbd->y.baseAddr=(unsigned char *)(image_vbd+1);
+    image_vbd->v.baseAddr=((unsigned char *)(image_vbd+1)) + width*height;
+    image_vbd->u.baseAddr=((unsigned char *)(image_vbd+1)) + width*height*5/4;
+    image_vbd->y.rowBytes=width;
+    image_vbd->v.rowBytes=width/2;
+    image_vbd->u.rowBytes=width/2;
+    *out=(void*)vidbufdec;
+
+    return 0;
+  }
+
+  return -1;
+
+}
+
+
+static IVideoDecoder *createVfw(int w, int h, double framerate, unsigned int type, int *flip)
+{
+  HIC gen_hic = ICOpen(ICTYPE_VIDEO, type, ICMODE_DECOMPRESS);
+
+  if (!gen_hic) return 0;
+
+  BITMAPINFO gen_bmo={0,},gen_bmi={0,};
+  gen_bmi.bmiHeader.biSize=sizeof(gen_bmi.bmiHeader);
+  gen_bmi.bmiHeader.biCompression = type; 
+  gen_bmi.bmiHeader.biHeight=h;
+  gen_bmi.bmiHeader.biWidth =w;
+  gen_bmi.bmiHeader.biPlanes=1;
+
+  gen_bmo.bmiHeader.biSize=sizeof(gen_bmo.bmiHeader);
+  gen_bmo.bmiHeader.biCompression = mmioFOURCC('Y','V','1','2');
+  gen_bmo.bmiHeader.biHeight=h;
+  gen_bmo.bmiHeader.biWidth =w;
+  gen_bmo.bmiHeader.biSizeImage=(w*h*3)/2;
+  gen_bmo.bmiHeader.biPlanes=1;
+  gen_bmo.bmiHeader.biBitCount=12;
+
+
+  if (ICERR_OK !=ICDecompressBegin(gen_hic, &gen_bmi, &gen_bmo))
+  {
+    ICClose(gen_hic);
+    return 0;
+  }
+  Gen_Decoder *t=new Gen_Decoder(w,h);
+  t->gen_bmi=gen_bmi;
+  t->gen_bmo=gen_bmo;
+  t->gen_hic=gen_hic;
+
+  return t;
+}
+
+#endif
+
+
+#ifdef BUILTIN_DIVX_SUPPORT
+#include "../../divx5/decore.h"
+
+class CrapDivxDecoder : public IVideoDecoder {
+  public:
+    CrapDivxDecoder(int w, int h)
+    {
+      predict_keyframes=1;
+	    divx_param.x_dim = w;
+	    divx_param.y_dim = h;
+	    divx_param.output_format = DEC_USER;
+      divx_param.codec_version = 412; // indicates that the stream is DivX 4.12 compatible
+      divx_param.build_number = 0; // in this case, the build field is ignored
+	    divx_param.time_incr = 15; // time_incr default value
+	          
+	    g_decore((long) this, DEC_OPT_MEMORY_REQS, &divx_param, &decMemReqs);
+
+      // the application allocates the data structures and the buffers
+      divx_param.buffers.mp4_edged_ref_buffers = malloc(decMemReqs.mp4_edged_ref_buffers_size);
+      divx_param.buffers.mp4_edged_for_buffers = malloc(decMemReqs.mp4_edged_for_buffers_size);
+      divx_param.buffers.mp4_edged_back_buffers = malloc(decMemReqs.mp4_edged_back_buffers_size);
+      divx_param.buffers.mp4_display_buffers = malloc(decMemReqs.mp4_display_buffers_size);
+      divx_param.buffers.mp4_state = malloc(decMemReqs.mp4_state_size);
+      divx_param.buffers.mp4_tables = malloc(decMemReqs.mp4_tables_size);
+      divx_param.buffers.mp4_stream = malloc(decMemReqs.mp4_stream_size);
+      divx_param.buffers.mp4_reference = malloc(decMemReqs.mp4_reference_size);
+
+      memset(divx_param.buffers.mp4_state, 0, decMemReqs.mp4_state_size);
+      memset(divx_param.buffers.mp4_tables, 0, decMemReqs.mp4_tables_size);
+      memset(divx_param.buffers.mp4_stream, 0, decMemReqs.mp4_stream_size);
+      memset(divx_param.buffers.mp4_reference, 0, decMemReqs.mp4_reference_size);
+
+      g_decore((long) this, DEC_OPT_INIT, &divx_param, NULL);
+    }
+    ~CrapDivxDecoder()
+    {
+      if (g_decore) 
+      {
+        g_decore((long) this,DEC_OPT_RELEASE,NULL,NULL);
+        free(divx_param.buffers.mp4_display_buffers);
+        free(divx_param.buffers.mp4_edged_for_buffers);
+        free(divx_param.buffers.mp4_edged_back_buffers);
+        free(divx_param.buffers.mp4_edged_ref_buffers);
+        free(divx_param.buffers.mp4_reference);
+        free(divx_param.buffers.mp4_state);
+        free(divx_param.buffers.mp4_stream);
+        free(divx_param.buffers.mp4_tables);
+      }
+      if (!--divx_cnt)
+      {
+        FreeModule(hDivxLib);
+        hDivxLib=0;
+        g_decore=0;
+      }
+    }
+    int decode(int need_kf, 
+            void *in, int in_len, 
+            void **out, // out is set to a pointer to data
+            unsigned int *out_type, // 'Y','V','1','2' is currently defined
+            int *is_kf)
+    {
+      *out_type=NSV_MAKETYPE('Y','V','1','2');
+      *out=NULL;
+      int kfpredict=0;
+      if (predict_keyframes && in_len>3) 
+      {
+        kfpredict=!((unsigned char *)in)[3];
+        if (need_kf && !kfpredict) return 0;
+      }
+      if (!in_len) return 0;
+      *is_kf=kfpredict;
+
+      DEC_PICTURE pic;
+      DEC_FRAME decFrame;
+
+	    decFrame.bitstream = in;
+	    decFrame.bmp = &pic;
+	    decFrame.length = in_len;
+	    decFrame.render_flag = 1;
+
+      DEC_FRAME_INFO fi;
+
+      if (g_decore((long) this, DEC_OPT_FRAME, &decFrame, &fi) == DEC_OK)
+      {
+        if (!kfpredict != !fi.intra) predict_keyframes=0;
+        *is_kf=fi.intra;
+        if (need_kf && !fi.intra) return 0;
+
+        image_vbd.y.baseAddr=(unsigned char *)pic.y;
+        image_vbd.u.baseAddr=(unsigned char *)pic.u;
+        image_vbd.v.baseAddr=(unsigned char *)pic.v;
+        image_vbd.y.rowBytes=pic.stride_y;
+        image_vbd.u.rowBytes=pic.stride_uv;
+        image_vbd.v.rowBytes=pic.stride_uv;
+
+        *out=&image_vbd;
+        return 0;
+      }
+
+      return -1;
+    }
+
+    void flush() { }
+
+    
+    static int (STDCALL *g_decore)(
+			    unsigned long handle,	// handle	- the handle of the calling entity, must be unique
+			    unsigned long dec_opt, // dec_opt - the option for docoding, see below
+			    void *param1,	// param1	- the parameter 1 (it's actually meaning depends on dec_opt
+			    void *param2);	// param2	- the parameter 2 (it's actually meaning depends on dec_opt
+    static HINSTANCE hDivxLib;
+    static int divx_cnt;
+
+  private:
+    DEC_PARAM divx_param;
+    YV12_PLANES image_vbd;
+    DEC_MEM_REQS decMemReqs;
+    int predict_keyframes;
+};
+
+int (STDCALL *CrapDivxDecoder::g_decore)(
+			  unsigned long handle,	// handle	- the handle of the calling entity, must be unique
+			  unsigned long dec_opt, // dec_opt - the option for docoding, see below
+			  void *param1,	// param1	- the parameter 1 (it's actually meaning depends on dec_opt
+			  void *param2)=0;	// param2	- the parameter 2 (it's actually meaning depends on dec_opt
+HINSTANCE CrapDivxDecoder::hDivxLib=0;
+int CrapDivxDecoder::divx_cnt=0;
+
+IVideoDecoder *DIVX_CREATE(int w, int h, double framerate, unsigned int fmt, int *flip)
+{
+  if (fmt == NSV_MAKETYPE('D','i','v','X'))
+  {
+    if (!CrapDivxDecoder::divx_cnt)
+    {
+      CrapDivxDecoder::hDivxLib=LoadLibrary("divx.dll");
+      if (CrapDivxDecoder::hDivxLib) *((void**)&CrapDivxDecoder::g_decore)=GetProcAddress(CrapDivxDecoder::hDivxLib,"decore");
+    }
+    CrapDivxDecoder::divx_cnt++;
+    if (CrapDivxDecoder::g_decore) return new CrapDivxDecoder(w,h);
+  }
+  return NULL;
+}
+
+#endif // end of divx gayness
+
+class NullVideoDecoder : public IVideoDecoder 
+{
+  public:
+    NullVideoDecoder() { }
+    ~NullVideoDecoder() { }
+    int decode(int need_kf, 
+            void *in, int in_len, 
+            void **out, // out is set to a pointer to data
+            unsigned int *out_type, // 'Y','V','1','2' is currently defined
+            int *is_kf)
+    {
+      *out_type=NSV_MAKETYPE('Y','V','1','2');
+      *is_kf=1;
+      *out=NULL;
+      return 0;
+    }
+    void flush() { }
+};
+
+
+class NullAudioDecoder : public IAudioDecoder
+{
+  public:
+    NullAudioDecoder(){}
+    ~NullAudioDecoder(){}
+    int decode(void *in, int in_len, 
+                       void *out, int *out_len,
+                       unsigned int out_fmt[8])
+    {
+      *out_len=0;
+      out_fmt[0]=NSV_MAKETYPE('N','O','N','E'); // no output
+      return 0;
+    }
+    void flush(){}
+};
+
+#ifdef BUILTIN_PCM_SUPPORT
+class PCMAudioDecoder : public IAudioDecoder
+{
+  public:
+    PCMAudioDecoder() { fused=4; }
+    ~PCMAudioDecoder(){}
+    int decode(void *in, int in_len,
+                       void *out, int *out_len,
+                       unsigned int out_fmt[8])
+    {
+      if (in_len < 4)
+      {
+        *out_len=0;
+        out_fmt[0]=0;
+        return 0; // screw this frame
+      }
+      unsigned char *t=(unsigned char *)in;
+      int bps=t[0];
+      int nch=t[1];
+      int srate=((int)t[2] | (((int)t[3])<<8));
+
+      out_fmt[0]=NSV_MAKETYPE('P','C','M',' ');
+      out_fmt[1]=srate;
+      out_fmt[2]=nch;
+      out_fmt[3]=bps;
+
+      int l=in_len-fused;
+      if (l > *out_len) l = *out_len;
+      l&=~(nch*(bps/8)-1);
+
+      if (l) memcpy(out,(char *)in + fused,l);
+      fused+=l;
+      *out_len=l;
+
+      if (fused >= in_len) 
+      {
+        fused=4;
+        return 0;
+      }
+      return 1;
+    }
+    void flush() { fused=4; }
+  private:
+    int fused;
+};
+#endif
+
+#ifdef DLL_DECODER_SUPPORT
+static char DLL_Dir[MAX_PATH];
+static HINSTANCE DLL_Handles[512];
+#endif
+
+
+void Decoders_Init(char *wapluginspath)
+{
+#ifdef DLL_DECODER_SUPPORT
+	HKEY hKey;
+
+  if (!DLL_Dir[0] && RegOpenKeyExA(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion",
+    0,KEY_READ,&hKey) == ERROR_SUCCESS)
+  {
+		DWORD l = sizeof(DLL_Dir);
+		DWORD t;
+    if (RegQueryValueExA(hKey,"CommonFilesDir",NULL,&t,(LPBYTE)DLL_Dir,&l ) != ERROR_SUCCESS || t != REG_SZ) DLL_Dir[0]=0;
+    DLL_Dir[sizeof(DLL_Dir)-5]=0;
+    CreateDirectoryA(DLL_Dir,NULL);
+    strcat(DLL_Dir,"\\NSV");
+    CreateDirectoryA(DLL_Dir,NULL);
+    RegCloseKey(hKey);
+  }
+
+  if (!DLL_Dir[0]) GetTempPathA(sizeof(DLL_Dir),DLL_Dir);
+  Decoders_Quit();
+
+  HANDLE h;
+  int x=0;
+  WIN32_FIND_DATAA fd = {0};
+  char buf[MAX_PATH*2+1] = {0};
+
+#ifndef DLL_DECODER_SUPPORT_NOCURDIR
+  char curdir[MAX_PATH] = {0};
+
+  strcpy( curdir, ".\\" );
+
+  strcpy( buf, curdir );
+  strcat( buf, "nsvdec_*.dll" );
+
+  OutputDebugString( buf ); OutputDebugString( "\n" );
+
+  h = FindFirstFile(buf,&fd);
+  if (h != INVALID_HANDLE_VALUE) 
+  {
+    do
+    {
+	  strcpy(buf,curdir);
+      strcat(buf,fd.cFileName);
+
+      DLL_Handles[x]=LoadLibrary(buf);
+      if (DLL_Handles[x])
+      {
+        if (GetProcAddress(DLL_Handles[x],"CreateVideoDecoder") ||
+            GetProcAddress(DLL_Handles[x],"CreateAudioDecoder")) x++;
+        else
+        {
+          FreeLibrary(DLL_Handles[x]);
+          DLL_Handles[x]=0;
+        }
+      }
+    } while (x < sizeof(DLL_Handles)/sizeof(DLL_Handles[0]) && FindNextFile(h,&fd));
+    FindClose(h);
+  }
+#endif
+
+#ifdef DLL_DECODER_SUPPORT_IN_
+
+  if (wapluginspath && wapluginspath[0])
+  {
+    lstrcpynA(buf,wapluginspath,sizeof(buf)-16);
+    strcat(buf,"\\in_*.dll");
+    h = FindFirstFileA(buf,&fd);
+    if (h != INVALID_HANDLE_VALUE) 
+    {
+      do
+      {
+        strncpy(buf, wapluginspath, MAX_PATH);
+        strncat(buf, "\\", MAX_PATH);
+        strncat(buf, fd.cFileName, MAX_PATH);
+
+        DLL_Handles[x]=LoadLibraryA(buf);
+        if (DLL_Handles[x])
+        {
+          if (GetProcAddress(DLL_Handles[x],"CreateVideoDecoder") ||
+              GetProcAddress(DLL_Handles[x],"CreateAudioDecoder")) x++;
+          else
+          {
+            FreeLibrary(DLL_Handles[x]);
+            DLL_Handles[x]=0;
+          }
+        }
+      } while (x < sizeof(DLL_Handles)/sizeof(DLL_Handles[0]) && FindNextFileA(h,&fd));
+      FindClose(h);
+    }
+    lstrcpynA(buf,wapluginspath,sizeof(buf)-16);
+    strcat(buf,"\\nsvdec_*.dll");
+    h = FindFirstFileA(buf,&fd);
+    if (h != INVALID_HANDLE_VALUE) 
+    {
+      do
+      {
+        strncpy(buf, wapluginspath, MAX_PATH);
+        strncat(buf, "\\", MAX_PATH);
+        strncat(buf, fd.cFileName, MAX_PATH);
+
+        DLL_Handles[x]=LoadLibraryA(buf);
+        if (DLL_Handles[x])
+        {
+          if (GetProcAddress(DLL_Handles[x],"CreateVideoDecoder") ||
+              GetProcAddress(DLL_Handles[x],"CreateAudioDecoder")) x++;
+          else
+          {
+            FreeLibrary(DLL_Handles[x]);
+            DLL_Handles[x]=0;
+          }
+        }
+      } while (x < sizeof(DLL_Handles)/sizeof(DLL_Handles[0]) && FindNextFileA(h,&fd));
+      FindClose(h);
+    }
+  }
+#endif
+
+#ifndef WINAMPX
+  strncpy(buf, DLL_Dir, MAX_PATH);
+  strncat(buf, "\\nsvdec_*.dll", MAX_PATH);
+  h = FindFirstFileA(buf,&fd);
+  if (h != INVALID_HANDLE_VALUE) 
+  {
+    do
+    {
+      strncpy(buf, DLL_Dir, MAX_PATH);
+      strncat(buf, "\\", MAX_PATH);
+      strncat(buf, fd.cFileName, MAX_PATH);
+
+      DLL_Handles[x]=LoadLibraryA(buf);
+      if (DLL_Handles[x])
+      {
+        if (GetProcAddress(DLL_Handles[x],"CreateVideoDecoder") ||
+            GetProcAddress(DLL_Handles[x],"CreateAudioDecoder")) x++;
+        else
+        {
+          FreeLibrary(DLL_Handles[x]);
+          DLL_Handles[x]=0;
+        }
+      }
+    } while (x < sizeof(DLL_Handles)/sizeof(DLL_Handles[0]) && FindNextFileA(h,&fd));
+    FindClose(h);
+  }
+#endif
+
+#endif
+}
+
+
+void Decoders_Quit()
+{
+#ifdef DLL_DECODER_SUPPORT
+  int x;
+  for (x = 0; x < sizeof(DLL_Handles)/sizeof(DLL_Handles[0]) && DLL_Handles[x]; x ++)
+  {
+    FreeLibrary(DLL_Handles[x]);
+    DLL_Handles[x]=0;
+  }
+#endif
+}
+
+static IAudioDecoder *CreateAudioDecoderWasabi(unsigned int type, IAudioOutput **output)
+{
+  int n = 0;
+  waServiceFactory *sf = 0;
+  while (sf = mod.service->service_enumService(WaSvc::NSVFACTORY, n++))
+  {
+    svc_nsvFactory *factory = (svc_nsvFactory *)sf->getInterface();
+    if (factory)
+    {
+      IAudioDecoder *decoder = factory->CreateAudioDecoder(type, output);
+      sf->releaseInterface(factory);
+      if (decoder)
+        return decoder;
+    }
+  }
+  return 0;
+}
+
+static IVideoDecoder *CreateVideoDecoderWasabi(int w, int h, double framerate, unsigned int type, int *flip)
+{
+  int n=0;
+  waServiceFactory *sf = 0;
+  while (sf = mod.service->service_enumService(WaSvc::NSVFACTORY, n++))
+  {
+    svc_nsvFactory *factory = (svc_nsvFactory *)sf->getInterface();
+    if (factory)
+    {
+      IVideoDecoder *decoder = factory->CreateVideoDecoder(w, h, framerate, type, flip);
+      sf->releaseInterface(factory);
+      if (decoder)
+        return decoder;
+    }
+  }
+  return 0;
+}
+
+IAudioDecoder *CreateAudioDecoder(unsigned int type, int *wasNotNull, IAudioOutput **output)
+{
+  IAudioDecoder *a=NULL;
+	if (mod.service && !a)
+		a = CreateAudioDecoderWasabi(type, output);
+#ifdef BUILTIN_MP3_SUPPORT
+  if (!a) a=MP3_CREATE(type);
+#endif
+#ifdef BUILTIN_PCM_SUPPORT
+  if (!a && type == NSV_MAKETYPE('P','C','M',' ')) a=new PCMAudioDecoder;
+#endif
+#ifdef BUILTIN_AAC_SUPPORT
+  extern IAudioDecoder *AAC_CREATE(unsigned int fmt, IAudioOutput **output);
+  if (!a && (type == NSV_MAKETYPE('A','A','C',' ') || type == NSV_MAKETYPE('V','L','B',' '))) a=AAC_CREATE(type,NULL);
+#endif
+#ifdef BUILTIN_AACP_SUPPOT
+	extern IAudioDecoder *AACP_CREATE(unsigned int fmt, IAudioOutput **output);
+  if (!a && (type == NSV_MAKETYPE('A','A','C','P') || type == NSV_MAKETYPE('A','A','C',' '))) a=AAC_CREATE(type,NULL);
+#endif
+#ifdef DLL_DECODER_SUPPORT
+  int x;
+  for (x = 0; !a && x < sizeof(DLL_Handles)/sizeof(DLL_Handles[0]) && DLL_Handles[x]; x ++)
+  {
+    IAudioDecoder *(*cad)(unsigned int type, IAudioOutput **output);
+    *((void**)&cad) = (void*)GetProcAddress(DLL_Handles[x],"CreateAudioDecoder");
+    if (cad) a=cad(type,output);
+  }
+#endif
+
+  if (!a)
+  {
+    *wasNotNull=0;
+		void *mem = WASABI_API_MEMMGR->sysMalloc(sizeof(NullAudioDecoder));
+		a = new (mem) NullAudioDecoder();
+  }
+  else *wasNotNull=1;
+  return a;
+}
+
+IVideoDecoder *CreateVideoDecoder(int w, int h, double framerate, unsigned int type, int *flip, int *wasNotNull)
+{
+  IVideoDecoder *v=NULL;
+	if (mod.service && !v)
+		v = CreateVideoDecoderWasabi(w, h, framerate, type, flip);
+#ifdef BUILTIN_DIVX_SUPPORT
+  if (!v) v=DIVX_CREATE(w,h,framerate,type,flip);
+#endif
+#ifdef BUILTIN_VP3_SUPPORT
+  if (!v) v=VP3_CREATE(w,h,framerate,type,flip);
+#endif
+#ifdef BUILTIN_VP5_SUPPORT
+  if (!v) v=VP5_CREATE(w,h,framerate,type,flip);
+#endif
+#ifdef BUILTIN_VP6_SUPPORT
+  extern IVideoDecoder *VP6_CREATE(int w, int h, double framerate, unsigned int fmt, int *flip);
+  if (!v) v=VP6_CREATE(w,h,framerate,type,flip);
+#endif
+#ifdef DLL_DECODER_SUPPORT
+  int x;
+  for (x = 0; !v && x < sizeof(DLL_Handles)/sizeof(DLL_Handles[0]) && DLL_Handles[x]; x ++)
+  {
+    IVideoDecoder *(*cvd)(int w, int h, double framerate, unsigned int type, int *flip);
+    *((void**)&cvd) = (void*)GetProcAddress(DLL_Handles[x],"CreateVideoDecoder");
+    if (cvd) v=cvd(w,h,framerate,type,flip);
+  }
+#endif
+#ifdef BUILTIN_VFW_SUPPORT
+  if (!v)
+  {
+    v=createVfw(w,h,framerate,type,flip);
+  }
+#endif
+  if (!v) 
+  {
+    if (wasNotNull) *wasNotNull=0;
+		void *mem = WASABI_API_MEMMGR->sysMalloc(sizeof(NullVideoDecoder));
+		v = new (mem) NullVideoDecoder();
+  }
+  else if (wasNotNull) *wasNotNull=1;
+
+  return v;
+}
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/main.cpp b/Src/nsv/nsvplay/main.cpp
new file mode 100644
index 00000000..76f2f5c1
--- /dev/null
+++ b/Src/nsv/nsvplay/main.cpp
@@ -0,0 +1,230 @@
+#include <windows.h>
+
+#include "main.h"
+#include "video.h"
+#include "resource.h"
+
+typedef struct
+{
+  VideoOutput *vidOut;
+  NSVDecoder *decode;
+  int quit;
+} parms;
+
+HINSTANCE g_hInstance;
+int g_bitmap_id=IDB_BITMAP1;
+
+//#define NO_ABOUT_EGG
+
+extern long glCounterNSVf, glSyncFrameCount, glNonSyncFrameCount;
+
+#define WNDMENU_CAPTION "NSVPlay/0.994"
+#include "about.h"
+#include "wndmenu.h"
+
+DWORD WINAPI pooThread(LPVOID p)
+{
+  parms *parm=(parms*)p;
+  unsigned int last_title_check=0;
+
+  while (!parm->quit)
+  {
+    int r=parm->decode->run(&parm->quit);
+    if (r < 0)
+    {
+      if (parm->decode->get_error()) MessageBox(parm->vidOut->getHwnd(),parm->decode->get_error(),"NSV Player Error",MB_OK|MB_ICONSTOP);
+      break;
+    }
+    else if (!r) 
+    {
+      if ((GetTickCount()-last_title_check) > 1000)
+      {
+        char *v=parm->decode->getTitle();
+        char *buf=(char*)malloc((v?strlen(v):0)+128);
+        int posms=parm->decode->getpos();
+        int lenms=parm->decode->getlen();
+        char *s=parm->decode->getStatus();
+        if (lenms != ~0)
+          wsprintf(buf,"%s [%d:%02d/%d:%02d] @ %dkbps %s%s%s- NSV Player",v?v:"",
+            posms/60000,(posms/1000)%60,
+            lenms/60000,(lenms/1000)%60,
+            parm->decode->getBitrate()/1000,
+            s?"[":"",s?s:"",s?"] ":""
+            );
+        else
+          wsprintf(buf,"%s [%d:%02d] @ %dkbps %s%s%s- NSV Player",v?v:"",
+            posms/60000,(posms/1000)%60,
+            parm->decode->getBitrate()/1000,
+            s?"[":"",s?s:"",s?"] ":""
+            );
+
+        char *p=buf;
+        while (*p)
+        {
+          if (*p == '_') *p=' ';
+          p++;
+        }
+        
+        SetWindowText(parm->vidOut->getHwnd(),buf);
+        free(buf);
+
+        last_title_check=GetTickCount();
+      }
+      Sleep(1);
+    }
+  }
+  parm->quit++;
+  return 0;
+}
+
+
+int g_quit;
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpszCmdParam, int nCmdShow) 
+{
+  g_hInstance=hInstance;
+
+  BOOL	bDisplayInfoAtEnd = FALSE;
+  char *subtitlefile=NULL;
+  char buf[11];
+  lstrcpyn(buf,lpszCmdParam,11);
+
+  if(strstr(lpszCmdParam, "/info")) {
+	  bDisplayInfoAtEnd = TRUE;
+  }
+
+  if (!lstrcmpi(buf,"/subtitle="))
+  {
+    lpszCmdParam += 10;
+    char scanc=' ';
+    if (*lpszCmdParam == '\"')
+    {
+      scanc=*lpszCmdParam++;
+    }
+    subtitlefile=lpszCmdParam;
+    while (*lpszCmdParam && *lpszCmdParam != scanc) lpszCmdParam++;
+    *lpszCmdParam++=0;
+    while (*lpszCmdParam == ' ') lpszCmdParam++;    
+  }
+
+  if (*lpszCmdParam == '\"') 
+  {
+    lpszCmdParam++;
+    char *p=strstr(lpszCmdParam,"\"");
+    if (p) *p=0;
+  }
+
+  if (!*lpszCmdParam) 
+  {
+    MessageBox(NULL,"Usage: nsvplay.exe [/subtitle=\"file|url\"] filename.nsv|http://url.nsv","NSV Player",MB_OK|MB_ICONINFORMATION);
+    return 0;
+  }
+
+  int xpos=CW_USEDEFAULT;
+  int ypos=CW_USEDEFAULT;
+
+  _ReadConfigItemInt("xpos",&xpos);
+  _ReadConfigItemInt("ypos",&ypos);
+
+  VideoOutput *vidOut = new VideoOutput(NULL,xpos,ypos);
+  Decoders_Init();
+
+  
+  NSVDecoder *decode=new NSVDecoder(lpszCmdParam,vidOut,subtitlefile);
+  vidOut->setNSVDecoder(decode);
+
+  int m_pause=0;
+
+  
+  vidOut->vid_vsync=false;
+
+
+  _ReadConfigItemInt("vsync",&vidOut->vid_vsync);
+  _ReadConfigItemInt("overlays",&vidOut->vid_overlays);
+  _ReadConfigItemInt("ddraw",&vidOut->vid_ddraw);
+  _ReadConfigItemInt("aspectadj",&vidOut->vid_aspectadj);
+  _ReadConfigItemInt("use_mixer",&g_audio_use_mixer);
+  {
+    int temp=1;
+    _ReadConfigItemInt("subtitles",&temp);
+    decode->enableSubs(temp);
+    temp=0;
+    _ReadConfigItemInt("subtitles_size",&temp);
+    decode->setSubsFontSize(temp);
+  }
+
+  DWORD id;
+  parms parm={0,};
+  parm.decode=decode;
+  parm.vidOut=vidOut;
+
+  vidOut->setcallback(my_wndcallback,&parm);
+  
+  HANDLE hThread=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)pooThread,(LPVOID)&parm,0,&id);
+
+  for (;;)
+  {
+    MSG msg;
+    while (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) 
+    {
+      if (msg.hwnd == vidOut->getHwnd() && msg.message == WM_KEYDOWN)
+      {
+        if (msg.wParam == VK_SPACE) decode->pause(m_pause=!m_pause);
+        if (msg.wParam == VK_LEFT) decode->seek(decode->getpos()-30000);
+        if (msg.wParam == VK_RIGHT) decode->seek(decode->getpos()+30000);
+        if (msg.wParam == VK_UP)
+        {
+          int vol=decode->getvolume()+16;
+          if (vol > 255) vol=255;
+          decode->setvolume(vol);
+        }
+        if (msg.wParam == VK_DOWN)
+        {
+          int vol=decode->getvolume()-16;
+          if (vol < 0) vol=0;
+          decode->setvolume(vol);
+        }
+        if (msg.wParam == VK_RETURN)
+        {
+          if (vidOut->is_fullscreen()) vidOut->remove_fullscreen();
+          else vidOut->fullscreen();
+        }
+        if (msg.wParam == 'v' || msg.wParam == 'V')
+        {
+          vidOut->vid_vsync=!vidOut->vid_vsync;
+        }
+        if (msg.wParam == 'a' || msg.wParam == 'A')
+        {
+          vidOut->vid_aspectadj=!vidOut->vid_aspectadj;
+          PostMessage(vidOut->getHwnd(),WM_TIMER,1,0);
+        }
+      }
+      DispatchMessage(&msg);
+    }
+
+    if (!IsWindow(vidOut->getHwnd()) || parm.quit) break;
+
+    Sleep(50);
+
+  }
+  parm.quit++;
+  WaitForSingleObject(hThread,INFINITE);
+  CloseHandle(hThread);
+  delete decode;
+  delete vidOut;
+
+  Decoders_Quit();
+
+#if _DEBUG
+  // if "/info" on the command line, display some statistics about the movie
+  if(bDisplayInfoAtEnd) {
+	char	szMessage[MAX_PATH];
+
+	wsprintf(szMessage, "File Header Count=%ld\nSync Frames=%ld\nNon-sync Frames=%ld", glCounterNSVf, glSyncFrameCount, glNonSyncFrameCount);
+	MessageBox(NULL, szMessage, WNDMENU_CAPTION, MB_OK);
+  }
+#endif
+
+  return 0;
+}
+
diff --git a/Src/nsv/nsvplay/main.h b/Src/nsv/nsvplay/main.h
new file mode 100644
index 00000000..a941cb01
--- /dev/null
+++ b/Src/nsv/nsvplay/main.h
@@ -0,0 +1,248 @@
+#ifndef NSVPLAY_MAIN_H
+#define NSVPLAY_MAIN_H
+
+#include <bfc/platform/types.h>
+#include "../nsvlib.h"
+#include "../dec_if.h"
+
+#define SHOW_STREAM_TITLE_AT_TOP 1
+
+class Subtitles;
+class SubsItem;
+
+#include "IDataReader.h"
+
+
+typedef struct
+{
+  const char *language;
+  const char *utf8_text;
+  unsigned int start_frame, end_frame;
+  unsigned char xPos, yPos;
+  unsigned char colorRed, colorGreen, colorBlue;
+  signed char fontSize;
+  int extraDataSize;
+  const void *extraData;
+} SUBTITLE_INFO;
+
+class IVideoOutput
+{
+  public:
+    virtual ~IVideoOutput() { }
+    virtual int open(int w, int h, int vflip, double aspectratio, unsigned int fmt)=0;
+#ifdef _WIN32
+    virtual void setcallback(LRESULT (*msgcallback)(void *token, HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam), void *token) { }
+#else
+		virtual void setcallback(void *func, void *token) { } // currently unused, here to reserve the spot in the vtable
+#endif
+    virtual void close()=0;
+    virtual void draw(void *frame)=0;
+    virtual void drawSubtitle(SubsItem *item) { }
+    virtual void showStatusMsg(const char *text) { }
+    virtual int get_latency() { return 0; }
+    virtual void notifyBufferState(int bufferstate) { } /* 0-255*/
+
+    virtual intptr_t extended(intptr_t param1, intptr_t param2, intptr_t param3) { return 0; } // Dispatchable, eat this!
+};
+
+template<class T>
+class ClassList {
+public:
+  ~ClassList() {
+    int l=getlen()-1;
+    for(int i=l;i>-1;i--) delete(get(i));
+  }
+  void put(T *item) {
+    m_buf.add(&item,sizeof(T *));
+  }
+  T *get(int n) {
+    if(n>=getlen()) return NULL;
+    return ((T **)m_buf.get())[n];
+  }
+  int getlen() {
+    return (int)(m_buf.getlen()/sizeof(SubsItem *));
+  }
+private:
+   GrowBuf m_buf;
+};
+
+class SubtitlesItem {
+public:
+  SubtitlesItem(const char *language, Subtitles *subs) :
+    m_subs(subs) { 
+      m_language=_strdup(language);
+      m_subs=subs;
+    }
+  ~SubtitlesItem() {
+    free((void *)m_language);
+  }
+  const char *m_language;
+  Subtitles *m_subs;
+};
+
+class NSVDecoder {
+
+public:
+
+  NSVDecoder(const char *url, IVideoOutput *output, char *subtitleurl=NULL);
+  ~NSVDecoder();
+
+  char *get_error();
+  char *get_status();
+  int run(int * volatile quit=NULL);
+
+  void pause(int pause);  
+  ULONGLONG getpos();
+  unsigned int getpos_frames() { return framecnt; }
+  unsigned int getlen(); // returns 0xFFFFFFFF on unknown
+  
+  void setvolume(int volume) { m_volume=volume; if (aud_output) aud_output->setvolume(volume); }
+  void setpan(int pan) { m_pan=pan; if (aud_output) aud_output->setpan(pan); }
+
+  int getvolume() { return m_volume; }
+  int getpan() { return m_pan; }
+
+  int canseek();
+  void seek(unsigned int newpos);
+
+  char *getFromMeta(char *name);
+  char *getUrl() { return m_url; }
+  const char *getServerHeader(char *name);
+
+  char *getTitle();
+  char *getStatus();
+
+  void getAudioDesc(char *buf);
+  void getVideoDesc(char *buf);
+
+  char *getAudioType() { return m_audio_type; }
+  char *getVideoType() { return m_video_type; }
+  unsigned int getFileSize(); // 0xFFFFFFFF if unknown
+  int   getBitrate();
+  int   getAudioBitrate();
+  int   getVideoBitrate();
+  int   getWidth() { return unpacket.getWidth(); }
+  int   getHeight() { return unpacket.getHeight(); }
+  double getFrameRate() { return use_framerate_override?framerate_override:unpacket.getFrameRate(); }
+  int   getBufferPos() { if (m_prebuffer) return m_bufstate; return 256; } // 0-256
+
+  int subsEnabled() { return m_enable_subtitles; }
+  void enableSubs(int e) { 
+    m_enable_subtitles=e; 
+    if(!e&&m_out) m_out->drawSubtitle(NULL); 
+  }
+  int getSubsFontSize() { return m_subs_fontsize; }
+  void setSubsFontSize(int s) { 
+    m_subs_fontsize=s; 
+    if(m_out) m_out->drawSubtitle(NULL); //will redraw current subtitle with new size
+  }
+
+  void SetPreciseSeeking(int prec) { m_precise_seeking=prec; }
+  void SetBuffering(int total_ms, int initial_ms, int after_underrun);
+  void SetBufferMemoryLimit(int bytes) { m_buf_memlimit=bytes; }
+
+  const char *getSubLanguage(int index);
+  void setSubLanguage(int index) { m_cur_subtitle=index; }
+  int getCurSubLanguage() { return m_cur_subtitle; }
+
+	void CloseVideo()
+	{
+		if (m_out_opened)
+			 m_out->close();
+		m_out_opened=0;
+	}
+
+private:
+  ULONGLONG m_avresync_time;
+  int m_pb_init,m_pb_init_ur,m_buffer_total;
+  int m_prebuffer;
+  int m_bufstate;
+
+  int	proTimerStart;
+	int proTimerEnd;
+	float profiletime;
+	float prostart;
+	float proend;
+	float timeref; 
+
+  int m_again;
+
+  void ProcessSubtitleBlock(void *data, int len);
+
+  int m_paused;
+
+  ULONGLONG hack_l_curpos;
+  ULONGLONG hack_l_curpos_ot;
+
+  int m_buf_memlimit;
+  IVideoOutput *m_out;
+  int m_out_opened;
+
+  nsv_InBS inbs;
+  nsv_InBS audiobs,videobs;  
+  nsv_InBS auxbs;
+  int video_frames_avail,audio_frames_avail;
+  nsv_Unpacketer unpacket;
+  unsigned int framecnt;
+  int hdrsearched;
+  int nsvbitstream_search;
+  int64_t m_audio_writepos;
+  unsigned int m_need_seek;
+
+  int seek_dumpframes, seek_dumpaudiosamples;
+  int pcm_samplerate;
+
+  int m_precise_seeking;
+
+  char *m_err;
+  char *m_url;
+  char *m_title;
+
+  int vid_decoder_isnotnull,aud_decoder_isnotnull;
+  IVideoDecoder *vid_decoder;
+  IAudioDecoder *aud_decoder;
+  IAudioOutput *aud_output;
+  IDataReader *file_reader;
+  int needkf;
+  double aspect;
+  double framerate_override;
+  int use_framerate_override;
+
+  nsv_fileHeader fileheader;
+
+  unsigned int avg_framesize_cnt,avg_framesize_tot;
+  unsigned int avg_framesize_cnt_v,avg_framesize_tot_v;
+  unsigned int avg_framesize_cnt_a,avg_framesize_tot_a;
+
+  int vidout_ready;
+  int vid_flip;
+  void *vidout;
+  unsigned int vidout_type;
+  unsigned int vidout_time;
+	unsigned int vidout_codec_width;
+	unsigned int vidout_codec_height;
+
+  char m_audio_type[5];
+  char m_video_type[5];
+
+  int m_volume, m_pan;
+
+  int m_enable_subtitles;
+  int m_subs_fontsize;
+  ClassList<SubtitlesItem> m_subtitles;
+  int m_cur_subtitle;
+
+  Subtitles *insertSubtitlesItem(const char *language, const char *subfile);
+  Subtitles *findSubtitles(const char *language);
+
+};
+
+void Decoders_Init(char *wapluginspath=NULL);
+void Decoders_Quit();
+
+
+IAudioDecoder *CreateAudioDecoder(unsigned int type, int *wasNotNull, IAudioOutput **output);
+IVideoDecoder *CreateVideoDecoder(int w, int h, double framerate, unsigned int type, int *flip, int *wasNotNull=NULL);
+IDataReader *CreateReader(const char *url);
+
+#endif //NSVPLAY_MAIN_H
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/mp3stub.cpp b/Src/nsv/nsvplay/mp3stub.cpp
new file mode 100644
index 00000000..72df533c
--- /dev/null
+++ b/Src/nsv/nsvplay/mp3stub.cpp
@@ -0,0 +1,73 @@
+#include "mp3stub.h"
+#include "../../mp3dec/mpgadecoder.h"
+
+int mp3_quality;
+int mp3_downmix;
+
+class MP3_Decoder : public IAudioDecoder
+{
+  public:
+    MP3_Decoder() : mp3_dec(mp3_quality,0,mp3_downmix) { fused=0; pcm_buf_used=0; }
+    ~MP3_Decoder() { };
+    int decode(void *in, int in_len, 
+                       void *out, int *out_len,
+                       unsigned int out_fmt[8]);
+    void flush() { fused=0; pcm_buf_used=0; mp3_dec.Reset(); }
+  private:
+    CMpgaDecoder mp3_dec;
+    char pcm_buf[1152*4*2];
+    int pcm_buf_used;
+    int pcm_offs;
+    int fused;
+};
+
+int MP3_Decoder::decode(void *in, int in_len, 
+                   void *out, int *out_len, 
+                   unsigned int out_fmt[8]) 
+{
+  int rval=1;
+  if (fused < in_len)
+  {
+    int l=mp3_dec.GetInputFree();
+    if (l > in_len-fused) l=in_len-fused;
+    if (l) mp3_dec.Fill((unsigned char *)in + fused,l);
+    fused+=l;
+  }
+
+  if (!pcm_buf_used)
+  {
+    SSC s=mp3_dec.DecodeFrame((unsigned char *)pcm_buf,sizeof(pcm_buf),&pcm_buf_used);
+    pcm_offs=0;
+  }
+
+  if (pcm_buf_used)
+  {
+    int l=*out_len;
+    if (l > pcm_buf_used) l=pcm_buf_used;
+    memcpy(out,pcm_buf+pcm_offs,l);
+    pcm_buf_used-=l;
+    pcm_offs+=l;
+    *out_len=l;
+  }
+  else 
+  {
+    if (fused >= in_len) rval=fused=0;
+    *out_len=0;
+  }
+
+  int nch=mp3_dec.m_Info.GetEffectiveChannels();
+  int srate=mp3_dec.m_Info.GetEffectiveSFreq();
+  out_fmt[0]=(nch && srate)?NSV_MAKETYPE('P','C','M',' '):0;
+  out_fmt[1]=srate;
+  out_fmt[2]=nch;
+  out_fmt[3]=(nch && srate)?16:0;
+
+  return rval;
+}
+
+
+IAudioDecoder *MP3_CREATE(unsigned int fmt)
+{
+  if (fmt == NSV_MAKETYPE('M','P','3',' ')) return new MP3_Decoder;
+  return NULL;
+}
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/mp3stub.h b/Src/nsv/nsvplay/mp3stub.h
new file mode 100644
index 00000000..11d6a148
--- /dev/null
+++ b/Src/nsv/nsvplay/mp3stub.h
@@ -0,0 +1,12 @@
+#ifndef _MP3STUB_H_
+#define _MP3STUB_H_
+
+#include "main.h"
+
+extern int mp3_quality;
+extern int mp3_downmix;
+extern int mp3_downshit;
+
+IAudioDecoder *MP3_CREATE(unsigned int fmt);
+
+#endif
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/nsv_logo.bmp b/Src/nsv/nsvplay/nsv_logo.bmp
new file mode 100644
index 00000000..bcdeaf9d
--- /dev/null
+++ b/Src/nsv/nsvplay/nsv_logo.bmp
diff --git a/Src/nsv/nsvplay/nsvdecode.cpp b/Src/nsv/nsvplay/nsvdecode.cpp
new file mode 100644
index 00000000..8d8bbcb7
--- /dev/null
+++ b/Src/nsv/nsvplay/nsvdecode.cpp
@@ -0,0 +1,999 @@
+#include <bfc/platform/platform.h>
+#include <bfc/platform/strcmp.h>
+#include <stdio.h>
+#include <locale.h>
+#include "audiostub.h"
+#include "api.h"
+#include "main.h"
+#include "subtitles.h"
+#include "../in_nsv/resource.h"
+
+extern int config_subtitles;
+#ifdef __APPLE__
+#include <sys/time.h>
+#include <unistd.h>
+uint32_t GetTickCount()
+{
+  struct timeval newtime;
+  
+	gettimeofday(&newtime, 0);
+  return newtime.tv_sec*1000 + newtime.tv_usec/1000;
+}
+
+int MulDiv(int a, int b, int d)
+{
+  return int ((int64_t)a * (int64_t)b) / (int64_t)d;
+}
+#endif
+class NullAudioOutput : public IAudioOutput 
+{
+  public:
+    NullAudioOutput() { m_pause=0; m_pause_t=0; m_start_t=GetTickCount64(); }
+    ~NullAudioOutput(){}
+    int canwrite() { return m_pause ? 0 : 65536; } // returns bytes writeable
+    void write(void *buf, int len) { }
+    ULONGLONG getpos() { return m_pause?m_pause_t:(GetTickCount64()-m_start_t); }
+    int isplaying(void) { return -1; }
+    ULONGLONG getwritepos() { return getpos(); }
+    void flush(unsigned int newtime) 
+    { 
+      if (m_pause) m_pause_t=newtime;
+      else m_start_t = GetTickCount64()-newtime; 
+    }
+    void pause(int pause)
+    {
+      if (pause && !m_pause)
+      {
+        m_pause_t=GetTickCount64()-m_start_t;
+        m_pause=1;
+      }
+      else if (!pause && m_pause)
+      {
+        m_start_t = GetTickCount64()-m_pause_t;
+        m_pause=0;
+        m_pause_t=0;
+      }
+    }
+
+  private:
+    int m_pause;
+    ULONGLONG m_pause_t;
+    ULONGLONG m_start_t;
+};
+
+void NSVDecoder::pause(int pause)
+{
+  if (aud_output) aud_output->pause(pause);
+  m_paused=pause;
+}
+
+ULONGLONG NSVDecoder::getpos()
+{
+  return aud_output ? aud_output->getpos() : 0;
+}
+
+unsigned int NSVDecoder::getlen()
+{
+  if (!fileheader.header_size || fileheader.file_lenms == 0xFFFFFFFF)
+  {
+    if (!file_reader || !avg_framesize_cnt || !avg_framesize_tot) return 0xFFFFFFFF;
+    int s=(int)file_reader->getsize();
+    if (s == 0xFFFFFFFF) return 0xFFFFFFFF;
+
+    int bytespersec=(int)((double)avg_framesize_tot/(double)avg_framesize_cnt*getFrameRate());
+
+    if (!bytespersec) return 0xFFFFFFFF;
+    return MulDiv(s,1000,bytespersec);
+  }
+  return fileheader.file_lenms;
+}
+
+void NSVDecoder::seek(unsigned int newpos)
+{
+  m_need_seek=newpos;
+  m_again=0;
+}
+
+int NSVDecoder::canseek()
+{
+  return file_reader ? file_reader->canseek() : 0;
+}
+
+char *NSVDecoder::getStatus()
+{
+  if (m_prebuffer) return "Buffering";
+  return NULL;
+}
+
+void NSVDecoder::SetBuffering(int total_ms, int initial_ms, int after_underrun)
+{
+  if (m_prebuffer) m_prebuffer=initial_ms;
+  m_pb_init=initial_ms;
+  m_pb_init_ur=after_underrun;
+  m_buffer_total=total_ms;
+}
+
+
+int64_t pdReadResolution(void)
+{
+  int64_t myfeq;
+#ifdef _WIN32
+  LARGE_INTEGER feq;
+
+  QueryPerformanceFrequency( &feq);
+  myfeq = feq.QuadPart;
+#else
+  myfeq = 1000000;
+#endif
+
+  return myfeq;
+}
+
+int64_t pdReadTimer(void)
+{
+  int64_t mynow;
+
+#ifdef _WIN32
+  LARGE_INTEGER now;
+  
+  QueryPerformanceCounter( &now );
+  mynow = now.QuadPart;
+#else
+  struct timeval newtime;
+
+	gettimeofday(&newtime,NULL);
+	mynow  = (newtime.tv_sec * 1000000) + newtime.tv_usec ;
+#endif
+
+  return mynow;
+}
+
+NSVDecoder::NSVDecoder(const char *url, IVideoOutput *output, char *subtitleurl)
+{
+  m_precise_seeking=1;
+  pcm_samplerate=0;
+  seek_dumpframes=0;
+  seek_dumpaudiosamples=0;
+  m_avresync_time=0;
+  nsvbitstream_search=0;
+  m_paused=0;
+  m_bufstate=0;
+  hack_l_curpos=-1;
+  hack_l_curpos_ot=0;
+  vid_decoder_isnotnull=1;
+  aud_decoder_isnotnull=1;
+  video_frames_avail=0;
+  audio_frames_avail=0;
+  m_buffer_total=1000; // bufferahead
+  m_pb_init=m_prebuffer=1500; // initial prebuffer
+  m_pb_init_ur=1500; // after underrun
+  m_buf_memlimit=32*1024*1024;
+  m_pan=0;
+  m_volume=192;
+  m_title=0;
+  m_audio_type[0]=m_video_type[0]=0;
+  m_out_opened=0;
+  m_out=output;
+  vidout_ready=0;
+  vidout=0;
+  vidout_type=0;
+  vidout_time=0;
+	vidout_codec_width=0;
+	vidout_codec_height=0;
+  m_url=_strdup(url);
+  m_need_seek=~0;
+  needkf=1;
+  aspect=1.0;
+  framerate_override=0.0;
+  use_framerate_override=0;
+  vid_decoder=NULL;
+  aud_decoder=NULL;
+  aud_output=NULL;
+  framecnt=0;
+  hdrsearched=0;
+  file_reader=CreateReader(url);
+  if (!file_reader) m_err="Error opening input";
+  else m_err=NULL;
+
+  m_enable_subtitles=1;
+  m_subs_fontsize=0;
+  m_cur_subtitle=0;
+  if (subtitleurl && *subtitleurl) insertSubtitlesItem("From subtitle file",subtitleurl);
+
+  memset(&fileheader,0,sizeof(fileheader));
+
+  avg_framesize_tot=0;
+  avg_framesize_cnt=0;
+  avg_framesize_tot_v=0;
+  avg_framesize_cnt_v=0;
+  avg_framesize_tot_a=0;
+  avg_framesize_cnt_a=0;
+
+  unpacket.setAudioOut(&audiobs);
+  unpacket.setVideoOut(&videobs);
+  unpacket.setAuxOut(&auxbs);
+
+	proTimerStart = 1;
+	proTimerEnd   = 0;
+	profiletime = 0.00;
+	prostart = 0.00;
+	proend = 0.00;
+	timeref = (float)pdReadResolution();
+
+
+  m_again = 0;
+}
+
+NSVDecoder::~NSVDecoder()
+{
+  if (m_out_opened) m_out->close();
+  if (WASABI_API_MEMMGR)
+		WASABI_API_MEMMGR->Delete(vid_decoder);
+	else
+		delete vid_decoder;
+	if (WASABI_API_MEMMGR)
+		WASABI_API_MEMMGR->Delete(aud_decoder);
+	else
+		delete aud_decoder;
+  delete aud_output;
+  delete file_reader;
+  free(fileheader.metadata);
+  free(fileheader.toc);
+  free(m_url);
+  free(m_title);
+}
+
+char *NSVDecoder::get_error()
+{
+  return m_err;
+}
+
+char *NSVDecoder::get_status()
+{
+  return NULL;
+}
+
+char *NSVDecoder::getFromMeta(char *name)
+{
+  if (file_reader)
+  {
+    char *t=(char*)malloc(strlen(name)+8);
+    if (t)
+    {
+      strcpy(t,"x-nsv-");
+      strcat(t,name); 
+      char *v=file_reader->getheader(t);
+      free(t);
+      if (v) return _strdup(v);
+    }
+  }
+  return nsv_getmetadata(fileheader.metadata,name);
+}
+
+
+unsigned int NSVDecoder::getFileSize()
+{
+  if (file_reader) return (unsigned int)file_reader->getsize();
+  return ~0;
+}
+
+int NSVDecoder::getBitrate()
+{
+  if (!fileheader.header_size || !fileheader.file_lenms || !fileheader.file_lenbytes ||
+    fileheader.file_lenms == 0xFFFFFFFF || fileheader.file_lenbytes == 0xFFFFFFFF)
+  {
+    if (!avg_framesize_cnt) return 0;
+    return (int) (8.0 * getFrameRate() * (double)avg_framesize_tot / (double)avg_framesize_cnt);
+  }
+  return MulDiv(fileheader.file_lenbytes,8000,fileheader.file_lenms);
+}
+
+const char *NSVDecoder::getServerHeader(char *name)
+{
+  return file_reader?file_reader->getheader(name):NULL;
+}
+
+void NSVDecoder::getAudioDesc(char *buf)
+{
+  char *t=getAudioType();
+  if (t && *t) 
+  {
+    if (strcmp(t, "VLB")==0)
+      sprintf(buf,"Dolby AAC ");   // special case; make sure the user never sees "VLB" name
+    else if (strcmp(t, "AACP")==0)
+			sprintf(buf,"HE-AAC ");
+		else if (strcmp(t, "AAC")==0)
+			sprintf(buf,"AAC LC ");
+		else
+      sprintf(buf,"%s ",t);
+
+    char *p=buf+strlen(buf);
+    if (aud_output) aud_output->getdescstr(p);
+    if (!*p) *--p=0;
+
+    int a=(getAudioBitrate()+500)/1000;
+	if (a) sprintf(buf+strlen(buf)," ~%d%s",a,WASABI_API_LNGSTRING(IDS_KBPS));
+  }
+  else *buf=0;
+}
+
+void NSVDecoder::getVideoDesc(char *buf)
+{
+  char *t=getVideoType();
+  if (t && *t) 
+  {
+    int fr=(int)(getFrameRate()*100.0);
+    sprintf(buf,"%s %dx%d@%d.%02d%s",t,getWidth(),getHeight(),fr/100,fr%100,WASABI_API_LNGSTRING(IDS_FPS));
+
+    int a=(getVideoBitrate()+500)/1000;
+	if (a) sprintf(buf+strlen(buf)," ~%d%s",a,WASABI_API_LNGSTRING(IDS_KBPS));
+  }
+  else *buf=0;
+}
+
+
+int NSVDecoder::getAudioBitrate()
+{
+  if (!avg_framesize_cnt_a) return 0;
+  return (int) (8.0 * getFrameRate() * (double)avg_framesize_tot_a / (double)avg_framesize_cnt_a);
+}
+
+int NSVDecoder::getVideoBitrate()
+{
+  if (!avg_framesize_cnt_v) return 0;
+  return (int) (8.0 * getFrameRate() * (double)avg_framesize_tot_v / (double)avg_framesize_cnt_v);
+}
+
+char *NSVDecoder::getTitle()
+{
+  char *v=getFromMeta("TITLE");
+  if (v) 
+  {
+    if (!m_title || strcmp(v,m_title)) 
+    {
+      free(m_title);
+      m_title=v;
+    }
+    else free(v);
+    return m_title;
+  }
+  if (file_reader)
+  {
+    v=file_reader->gettitle();
+    if (v) return v;
+  }
+
+  if (!m_url) return "";
+
+  v=m_url+strlen(m_url);
+  while (v >= m_url && *v != '/' && *v != '\\' && *v != '=') v--;
+  return ++v;
+}
+
+void NSVDecoder::ProcessSubtitleBlock(void *data, int len)
+{
+  unsigned char *dataptr=(unsigned char *)data;
+  while (len > 2)
+  {
+    int len_block=(dataptr[0] | ((unsigned short)dataptr[1] << 8)); 
+    dataptr += 2;
+    len -= 2;
+    if (len_block > len) break;
+  
+    SUBTITLE_INFO sti={0,};
+    sti.language = (char *)dataptr;
+    while (len_block > 0 && *dataptr)
+    {
+      dataptr++;
+      len_block--;
+      len--;
+    }
+    dataptr++;
+    len_block--;
+    len--;
+    if (len_block < 1) break;
+    sti.utf8_text = (char *)dataptr;
+    while (len_block > 0 && *dataptr)
+    {
+      dataptr++;
+      len_block--;
+      len--;
+    }
+    dataptr++;
+    len_block--;
+    len--;
+    if (len_block < 6) break;
+
+    sti.start_frame = framecnt + video_frames_avail + (dataptr[0] | ((int)dataptr[1] << 8));
+    dataptr+=2;
+    len-=2;
+    len_block-=2;
+
+    sti.end_frame = sti.start_frame + (dataptr[0] | ((int)dataptr[1] << 8) | ((int)dataptr[2] << 16) | ((int)dataptr[3] << 24));
+    dataptr+=4;
+    len-=4;
+    len_block-=4;
+
+    // set defaults for color/position
+    sti.xPos=128;
+    sti.yPos=255;
+    sti.colorRed=255;
+    sti.colorGreen=255;
+    sti.colorBlue=255;
+    sti.fontSize=0;
+
+    if (len_block >= 2)
+    {
+      sti.xPos = *dataptr++;
+      sti.yPos = *dataptr++;
+      len-=2;
+      len_block-=2;
+      if (len_block >= 3)
+      {
+        sti.colorRed=*dataptr++;
+        sti.colorGreen=*dataptr++;
+        sti.colorBlue=*dataptr++;
+        len-=3;
+        len_block-=3;
+        if (len_block > 0)
+        {
+          sti.fontSize=(signed char) *dataptr++;
+          len--;
+          len_block--;
+        }
+
+        if (len_block > 0)
+        {
+          sti.extraData=dataptr;
+          sti.extraDataSize=len_block;
+        }
+
+      }
+    }
+
+    Subtitles *sub=findSubtitles(sti.language);
+    if(!sub) sub=insertSubtitlesItem(sti.language,NULL);
+    sub->addSubtitlePacket(&sti);
+
+    if (len_block > 0)
+    {
+      len-=len_block;
+      dataptr+=len_block;
+    }
+
+  }
+}
+
+int NSVDecoder::run(int * volatile quit) // returns -1 on error, 0 if no frames processed, 1 if frames processed, 2 if underrun
+{
+  int retval=0;
+
+
+  if (!file_reader) return -1;
+
+  if (!aud_decoder_isnotnull && !vid_decoder_isnotnull && vid_decoder && aud_decoder)
+  {
+    m_err="Codec(s) not found";
+    return -1;
+  }
+
+  if (aud_output && vidout_ready)
+  {
+      ULONGLONG curpos=aud_output->getpos();
+    if (!m_paused)
+    {
+      if (!audio_frames_avail && curpos == hack_l_curpos && unpacket.getEof())
+      {
+        hack_l_curpos=curpos;
+        curpos += GetTickCount64() - hack_l_curpos_ot;
+      }
+      else
+      {
+        hack_l_curpos_ot=GetTickCount64();
+        hack_l_curpos=curpos;
+      }
+    }
+
+    if (curpos >= vidout_time && !m_prebuffer)
+    {
+			if (vidout) 
+			{
+				// send this to get the flip state updated so when toggled on-the-fly it will work with nsv
+				m_out->extended(0x1002/*VIDUSER_SET_VFLIP*/,vid_flip,0);
+				m_out->draw(vidout);
+			}
+
+      if (m_enable_subtitles) 
+      {
+        SubtitlesItem *it=m_subtitles.get(m_cur_subtitle);
+        if(it && config_subtitles) {
+          it->m_subs->setFontSizeModifier(m_subs_fontsize);
+          m_out->drawSubtitle(it->m_subs->getSubtitle((unsigned int)aud_output->getpos(),framecnt));
+        }
+		if ( it && !config_subtitles )
+		{
+			m_out->drawSubtitle(NULL);
+		}
+      }
+      vidout=0;
+      vidout_ready=0;
+    }
+  }
+
+  if (hdrsearched && m_need_seek!=~0 && aud_output)
+  {
+    unsigned int newpos=m_need_seek;
+    m_need_seek=~0;
+    seek_dumpaudiosamples=0;
+    seek_dumpframes=0;
+    if (file_reader->canseek() && file_reader->getsize() != 0xFFFFFFFF)
+    {
+      int nbpos;
+
+      if (!fileheader.toc_size || !fileheader.toc || !fileheader.file_lenms || 
+          !fileheader.file_lenbytes ||
+          fileheader.file_lenms == 0xFFFFFFFF || fileheader.file_lenbytes == 0xFFFFFFFF)
+      {
+        int avg_framesize=avg_framesize_tot/avg_framesize_cnt;
+        int pos_frames=(int)(newpos*getFrameRate());
+        nbpos=fileheader.header_size+MulDiv(pos_frames,avg_framesize,1000);
+      }
+      else // calculate offset using TOC
+      {
+        if (fileheader.toc_ex) // use extended toc, find next earliest time closest
+        {
+          int x;
+          double scale;
+          if (unpacket.isValid() && getFrameRate() > 0.0001)
+            scale=1000.0 / getFrameRate();
+          else scale = 1000.0 / 30.0;
+          for (x = 0; x < (int)fileheader.toc_size; x ++)
+          {
+            if (newpos < (unsigned int) (fileheader.toc_ex[x]*scale)) break;
+          }
+          unsigned int hdr[2]={0,0};
+          if (--x >= 0)
+          {
+            hdr[0]=fileheader.toc[x];
+            hdr[1]=(unsigned int) (fileheader.toc_ex[x] * scale);
+          }
+          //hdr[1] is the time of that keyframe
+
+          if (m_precise_seeking) // precise seek
+          {
+            int timediff = newpos - hdr[1];
+            double fr;
+            if (unpacket.isValid() && getFrameRate() >= 0.0001) fr = getFrameRate() / 1000.0;
+            else fr = 30.0 / 1000.0;
+
+            seek_dumpframes=(int) (timediff * fr);
+            seek_dumpaudiosamples=MulDiv(timediff,pcm_samplerate,1000);
+          }
+          else
+          {
+            newpos=hdr[1];
+          }
+
+          nbpos = fileheader.header_size + hdr[0];
+        }
+        else
+        {
+          double tocpos=(newpos*(double)fileheader.toc_size)/(double)fileheader.file_lenms;
+          unsigned int tocidx=(unsigned int)tocpos;
+          if (tocidx > fileheader.toc_size)
+          {
+            nbpos=fileheader.header_size + fileheader.file_lenbytes;
+          }
+          else
+          {
+            unsigned int a,b;
+            if (tocidx<0) tocidx=0;
+            a = fileheader.toc[tocidx];
+            if (tocidx < fileheader.toc_size-1)
+              b = fileheader.toc[tocidx+1];
+            else b=fileheader.file_lenbytes;
+            double frac=tocpos-tocidx;
+          
+            nbpos = fileheader.header_size + (int) (a * (1.0 - frac) + b * frac);
+          }
+        }
+      }
+      if (!file_reader->seek(nbpos))
+      {
+        framecnt=(int)(newpos*getFrameRate()/1000.0);     
+        unpacket.reset(0);
+        unpacket.setEof(0);
+        hdrsearched=1;
+        needkf=1;
+        m_avresync_time=0;
+        vidout=0;
+        vidout_ready=0;
+        video_frames_avail=0;
+        audio_frames_avail=0;
+        m_prebuffer=m_pb_init;
+        inbs.clear();
+        audiobs.clear();
+        videobs.clear();
+        auxbs.clear();
+        if (aud_output) aud_output->flush(newpos);
+        if (aud_decoder) aud_decoder->flush();
+        if (vid_decoder) vid_decoder->flush();
+   	  }
+    }
+  } // end of seeking
+
+  if (!hdrsearched) // search for header
+  {
+readagain_header:
+    if (quit && *quit) return 0;
+    int ret=nsv_readheader(inbs,&fileheader);
+    if (ret <= 0) 
+    {
+      hdrsearched++;
+      if (!ret)
+      {
+		_locale_t C_locale = WASABI_API_LNG->Get_C_NumericLocale();
+        char *v=getFromMeta("ASPECT");
+        if (v)
+		{
+		  aspect=_atof_l(v,C_locale);
+		}
+        free(v);
+        v=getFromMeta("FRAMERATE");
+        if (v)
+        {
+          framerate_override=_atof_l(v,C_locale);
+          if (framerate_override >= 0.01) use_framerate_override=1;
+          free(v);
+        }
+      }
+    }
+    else
+    {
+      char buf[8192] = {0};
+      size_t ret2=file_reader->read(buf,sizeof(buf));
+      
+      if (file_reader->iseof()) unpacket.setEof(1);
+
+      if (file_reader->geterror()) 
+      {
+        m_err=file_reader->geterror();
+        return -1;
+      }
+      if (ret2>0) 
+      {
+        inbs.add(buf, (int)ret2);
+        goto readagain_header;
+      }
+    }
+  }
+  if (!hdrsearched) return 0;
+  // end of header search
+
+  // read from source
+  if (m_prebuffer || 
+    (((!unpacket.isValid() || audio_frames_avail < (int)((getFrameRate() * m_buffer_total)/1000.0)) || !videobs.avail()) && 
+        (!m_buf_memlimit || ((int)(audiobs.avail()+videobs.avail()) < m_buf_memlimit*8))))
+  {
+readagain_stream:
+    if (quit && *quit) return 0;
+    int lavail= (int)inbs.avail();
+
+    int ret=unpacket.unpacket(inbs);
+  
+    inbs.compact();
+
+    if (ret)
+    {
+      if (!unpacket.isValid() && nsvbitstream_search > 8*1024*1024) // only scan for 8mb max
+      {
+        m_err="Error synching to NSV stream";
+        return -1;
+      }
+      if (unpacket.getEof())
+      {
+        if (!videobs.avail() && !video_frames_avail && (!aud_output || aud_output->isplaying() <= 0))  retval=-1;
+      // do nothing
+      }
+      else
+      {
+        char buf[8192] = {0};
+
+        size_t ret2=file_reader->read(buf,sizeof(buf));
+      
+        if (ret2 == 0 && file_reader->iseof()) 
+        {
+          m_prebuffer=0;
+          unpacket.setEof(1);
+        }
+
+        if (file_reader->geterror()) 
+        {
+          m_err=file_reader->geterror();
+          return -1;
+        }
+
+        if (ret2 > 0) 
+        {
+          nsvbitstream_search+= (int)ret2;
+          inbs.add(buf, (int)ret2);
+          goto readagain_stream;
+        }
+      }
+    }
+    else
+    {
+      nsvbitstream_search=0;
+      video_frames_avail++;
+      audio_frames_avail++;
+      nsv_type_to_string(unpacket.getAudFmt(),m_audio_type);
+      nsv_type_to_string(unpacket.getVidFmt(),m_video_type);
+
+      avg_framesize_cnt++;
+      avg_framesize_tot+=lavail- (int)((inbs.avail())/8);
+      if (avg_framesize_tot > 0x80000000)
+      {
+        avg_framesize_tot/=2;
+        avg_framesize_cnt/=2;
+      }
+
+      if (1)
+      {
+        //parse aux packets
+        while (auxbs.avail() >= 8*8)
+        {
+          size_t thislen = auxbs.getbits(32);
+          unsigned int thistype = auxbs.getbits(32);
+          if (thislen > auxbs.avail()/8) break;
+
+          if (thistype == NSV_MAKETYPE('S','U','B','T')  ) ProcessSubtitleBlock(auxbs.getcurbyteptr(), (int)thislen);
+          else if (thistype == NSV_MAKETYPE('A','S','Y','N'))
+          {
+            //if (thislen == 0) // resyncpoint
+            {
+              audiobs.addint(-1);
+              audiobs.addint(framecnt+video_frames_avail);
+            }
+            //else // handle other form [todo]
+            //{
+            //}
+          }
+
+          auxbs.seek(thislen*8);
+        }
+      }
+      auxbs.clear();
+    }
+  }
+
+  if (unpacket.isValid() && !m_prebuffer && !audiobs.avail() && aud_output)
+  {
+    if (aud_output->isplaying()) aud_output->write(0,0);
+    else  if (!unpacket.getEof())
+    {
+      m_prebuffer=m_pb_init_ur+(int)((video_frames_avail/getFrameRate())*1000.0);
+      if (m_prebuffer < m_pb_init_ur) m_prebuffer=m_pb_init_ur;
+      if (m_prebuffer > m_pb_init_ur*3) m_prebuffer=m_pb_init_ur*3;
+      retval=2;
+    }
+  }
+
+  if (video_frames_avail > (int)((m_prebuffer*getFrameRate())/1000.0)) 
+  {
+    m_bufstate=256;
+    m_prebuffer=0;
+  }
+  else
+  {
+    int a = (int) (video_frames_avail * 256.0 / ((m_prebuffer*getFrameRate())/1000.0));
+    if (a > 255) a=255;
+    if (a < 0) a=0;
+    m_bufstate=a;
+    if (m_out) m_out->notifyBufferState(a);
+  }
+
+  if (unpacket.isValid() && !vidout_ready && videobs.avail() && !m_prebuffer) // decode frame
+  {
+    if (!vid_decoder)
+    {
+      vid_flip=0;
+      vid_decoder = CreateVideoDecoder(unpacket.getWidth(),unpacket.getHeight(),
+        getFrameRate(),unpacket.getVidFmt(),&vid_flip,&vid_decoder_isnotnull);
+    }
+
+    int kf=0;
+    int l=videobs.getbits(32);
+		unsigned int local_vidout_type[3] = { 1, 0, 0 };
+    int ret=vid_decoder->decode(needkf,videobs.getcurbyteptr(),l,&vidout,local_vidout_type,&kf);
+		vidout_type = local_vidout_type[0];
+		if (ret == 0)
+		{
+			
+			vidout_codec_width = local_vidout_type[1];
+			vidout_codec_height = local_vidout_type[2];
+		}
+
+    if (kf) needkf=0;
+    video_frames_avail--;
+    videobs.seek(l*8);
+    videobs.compact();
+
+    avg_framesize_cnt_v++;
+    avg_framesize_tot_v+=l;
+
+    if (needkf || seek_dumpframes > 0)
+    {
+      vidout=NULL;
+      if (seek_dumpframes>0) seek_dumpframes--;
+    }
+    else
+    {
+      if (!m_out_opened && vid_decoder_isnotnull) 
+      {
+				m_out->extended(0x1008/*VIDUSER_SET_THREAD_SAFE*/, 1, 0);
+				unsigned int vidwidth = vidout_codec_width, vidheight = vidout_codec_height;
+				if (vidwidth && vidheight)
+				{
+					/* if the codec provided a width/height to use */
+					double aspect_adjust = (double)vidwidth / (double)vidheight / ((double)unpacket.getWidth() / (double)unpacket.getHeight());
+					if (m_out->open(vidwidth,vidheight,vid_flip,aspect * aspect_adjust,vidout_type))
+					{
+						m_err="Error opening video output";
+	          return -1;
+					}
+				}
+				else
+				{
+					if (m_out->open(unpacket.getWidth(),unpacket.getHeight(),vid_flip,aspect,vidout_type))
+					{
+						m_err="Error opening video output";
+	          return -1;
+					}
+				}
+        m_out_opened=1;
+      }
+
+      vidout_ready=1;
+      vidout_time = (unsigned int)(framecnt++ / getFrameRate() * 1000.0) + (unsigned int)m_avresync_time;
+      int offs=unpacket.getSyncOffset() + m_out->get_latency();
+
+      if ((int)vidout_time <= offs) vidout_time=0;
+      else vidout_time-=offs;
+
+      //drop the image if we're late
+      if(aud_output && vidout_time<aud_output->getpos()) {
+        vidout=0;
+        vidout_ready=0;
+      }
+    }
+
+    retval=1;
+  }
+
+  if ( ( audiobs.avail() && !m_prebuffer ) || m_again )
+  {
+    if (needkf)
+    {
+      int l=audiobs.getbits(32);
+      if (l == -1) audiobs.seek(32); // skip over 32 bits of our audiobs info
+      else
+      {
+        audiobs.seek(l*8);
+        audio_frames_avail--;
+      }      
+
+      audiobs.compact();
+    }
+    else // decode some audio
+    {
+      char pcmbuf[16384] = {0};
+      int outbufl=512;
+      if (!aud_decoder)
+      {
+        aud_decoder=CreateAudioDecoder(unpacket.getAudFmt(),&aud_decoder_isnotnull,&aud_output);
+        if (aud_output && m_paused) aud_output->pause(1);
+      }
+      
+      if (aud_output) outbufl=aud_output->canwrite();
+      
+      if (outbufl)
+      {
+        unsigned int outfmt[8] = {0};
+
+        retval=1;
+        if (outbufl > sizeof(pcmbuf)) outbufl=sizeof(pcmbuf);
+
+        int inl=audiobs.getbits(32);
+
+        if (inl == -1)
+        {
+          int vidframe=audiobs.getbits(32);
+          if (aud_output)
+          {
+            ULONGLONG audpos = aud_output->getwritepos();
+            int vidpos = (int)(vidframe / getFrameRate() * 1000.0);
+
+            m_avresync_time = audpos-vidpos;
+          }
+        }
+        else
+        {
+          int ret=aud_decoder->decode(audiobs.getcurbyteptr(), inl, pcmbuf, &outbufl, outfmt);
+
+          if ( !outbufl ) m_again = 0;
+          else m_again =1;
+
+          if (ret < 1)
+          {
+            avg_framesize_cnt_a++;
+            avg_framesize_tot_a+=inl;
+            audiobs.seek(inl*8);
+            audiobs.compact();
+            audio_frames_avail--;
+          }
+          else audiobs.seek(-32);
+
+          if (outbufl || outfmt[0])
+          {
+            if (!aud_output)
+            {
+              aud_output=PCMOUT_CREATE(outfmt);
+              pcm_samplerate=outfmt[1];
+              if (!aud_output) aud_output = new NullAudioOutput;
+              aud_output->setvolume(m_volume);
+              aud_output->setpan(m_pan);
+              if (aud_output && m_paused) aud_output->pause(1);
+            }
+            if (outbufl) 
+            {
+              if (seek_dumpaudiosamples)
+              {
+                int nch=outfmt[2];
+                int bps=outfmt[3];
+                int dump=seek_dumpaudiosamples*nch*(bps/8);
+                if (dump >= outbufl)
+                {
+                  seek_dumpaudiosamples -= outbufl/nch/(bps/8);
+                }
+                else // partial write
+                {                  
+                  aud_output->write(pcmbuf+dump,outbufl-dump);
+                  seek_dumpaudiosamples=0;
+                }
+              }
+              else aud_output->write(pcmbuf,outbufl);
+            }
+          }
+        }
+      } // if can write
+    } //end of decode
+  } // audiobs avail
+
+  if (m_prebuffer) 
+#ifdef _WIN32
+		Sleep(10);
+#else
+		usleep(10000);
+#endif
+  
+  return retval;
+}
+
+Subtitles *NSVDecoder::insertSubtitlesItem(const char *language, const char *subfile) {
+  Subtitles *sub=new Subtitles(subfile);
+  m_subtitles.put(new SubtitlesItem(language, sub));
+  return sub;
+}
+
+Subtitles *NSVDecoder::findSubtitles(const char *language) {
+  for(int i=0;i<m_subtitles.getlen();i++) {
+    SubtitlesItem *s=m_subtitles.get(i);
+    if(!_stricmp(language,s->m_language) ) return s->m_subs;
+  }
+  return NULL;
+}
+
+const char *NSVDecoder::getSubLanguage(int index) {
+  if(index>=m_subtitles.getlen()) return NULL;
+  return m_subtitles.get(index)->m_language;
+}
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/nsvplay.dsp b/Src/nsv/nsvplay/nsvplay.dsp
new file mode 100644
index 00000000..4b49c0b1
--- /dev/null
+++ b/Src/nsv/nsvplay/nsvplay.dsp
@@ -0,0 +1,464 @@
+# Microsoft Developer Studio Project File - Name="nsvplay" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=nsvplay - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "nsvplay.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "nsvplay.mak" CFG="nsvplay - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "nsvplay - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "nsvplay - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "nsvplay - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MT /W3 /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "USE_ASM" /D "NO_LAYER12" /D "DLL_DECODER_SUPPORT" /D "BUILTIN_MP3_SUPPORT" /D "BUILTIN_VP3_SUPPORT" /D "SUBTITLES_READER" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib ddraw.lib wsock32.lib vfw32.lib /nologo /subsystem:windows /machine:I386 /out:"c:\nsv\nsvplay.exe"
+
+!ELSEIF  "$(CFG)" == "nsvplay - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D "BUILTIN_VFW_SUPPORT" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "USE_ASM" /D "NO_LAYER12" /D "DLL_DECODER_SUPPORT" /D "BUILTIN_MP3_SUPPORT" /D "BUILTIN_VP3_SUPPORT" /D "SUBTITLES_READER" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib ddraw.lib winmm.lib wsock32.lib vfw32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"c:\nsv\nsvplay.exe" /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "nsvplay - Win32 Release"
+# Name "nsvplay - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Group "audio"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\audiostub.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\audiostub.h
+# End Source File
+# End Group
+# Begin Group "vp3"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\vp32\include\duck_dxl.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\vp3stub.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vp3stub.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\vp32\lib\win32\Release\s_cpuid.lib
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\vp32\lib\win32\Release\s_dxv.lib
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\vp32\lib\win32\Release\s_sal.lib
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\vp32\lib\win32\Release\s_vp31d.lib
+# End Source File
+# End Group
+# Begin Group "mp3dec"
+
+# PROP Default_Filter ""
+# Begin Group "fhg"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\mp3dec\bitsequence.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\bitstream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\bitstream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\conceal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\conceal.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\crc16.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\crc16.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\giobase.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\huffdec.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\huffdec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\huffmanbitobj.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\huffmandecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\huffmandecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\huffmantable.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\huffmantable.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\l3table.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\l3table.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mdct.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mdct.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp2decode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp2decode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3decode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3decode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3quant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3quant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3read.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3read.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3ssc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3ssc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3sscdef.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3streaminfo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3tools.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mp3tools.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mpeg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mpegbitstream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mpegbitstream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mpegheader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mpegheader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mpgadecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\mpgadecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\polyphase.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mp3dec\polyphase.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\mp3stub.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mp3stub.h
+# End Source File
+# End Group
+# Begin Group "nsv"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\nsvbs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\nsvlib.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\nsvlib.h
+# End Source File
+# End Group
+# Begin Group "jnetlib"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\jnetlib\asyncdns.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\asyncdns.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\connection.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\connection.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\httpget.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\httpget.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\jnetlib.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\netinc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\util.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\jnetlib\util.h
+# End Source File
+# End Group
+# Begin Group "video"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\vid_ddraw.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vid_ddraw.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\vid_overlay.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vid_overlay.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\video.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\video.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\about.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\decoders.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\nsvdecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\nsvplay.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\readers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\subtitles.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\wndmenu.h
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\main.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\subtitles.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# Begin Source File
+
+SOURCE=.\nsv_logo.bmp
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/Src/nsv/nsvplay/nsvplay.dsw b/Src/nsv/nsvplay/nsvplay.dsw
new file mode 100644
index 00000000..2fafc97e
--- /dev/null
+++ b/Src/nsv/nsvplay/nsvplay.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "nsvplay"=.\nsvplay.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/Src/nsv/nsvplay/nsvplay.rc b/Src/nsv/nsvplay/nsvplay.rc
new file mode 100644
index 00000000..43e1fde4
--- /dev/null
+++ b/Src/nsv/nsvplay/nsvplay.rc
@@ -0,0 +1,106 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_ABOUT DIALOG DISCARDABLE  0, 0, 184, 54
+STYLE DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "About..."
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,105,33,50,14
+    CTEXT           "Static",IDC_VERSION,74,7,103,8
+    CTEXT           "Copyright (C) 2003 Nullsoft",IDC_STATIC,74,16,103,8
+    CONTROL         102,IDC_STATIC,"Static",SS_BITMAP,7,7,67,39
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO DISCARDABLE 
+BEGIN
+    IDD_ABOUT, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 177
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 47
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Bitmap
+//
+
+IDB_BITMAP1             BITMAP  DISCARDABLE     "nsv_logo.bmp"
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/Src/nsv/nsvplay/readers.cpp b/Src/nsv/nsvplay/readers.cpp
new file mode 100644
index 00000000..ff048e70
--- /dev/null
+++ b/Src/nsv/nsvplay/readers.cpp
@@ -0,0 +1,949 @@
+#include <windows.h>
+#include "main.h"
+#include <sys/stat.h>
+
+#ifdef NO_WASABI
+#include "../../jnetlib/httpget.h"
+api_httpreceiver *CreateGet() 
+{
+	return new JNL_HTTPGet;
+}
+
+void ReleaseGet(api_httpreceiver *&get)
+{
+	delete (JNL_HTTPGet *)get;
+	get=0;
+}
+#else
+#include "../..\Components\wac_network\wac_network_http_receiver_api.h"
+#include <api.h>
+#include <api/service/waservicefactory.h>
+#include "../../Winamp/in2.h"
+extern In_Module mod;
+
+waServiceFactory *httpFactory = 0;
+api_httpreceiver *CreateGet()
+{
+	api_httpreceiver *get = 0;
+	if (!httpFactory && mod.service)
+		httpFactory = mod.service->service_getServiceByGuid(httpreceiverGUID);
+
+	if (httpFactory)
+		get = (api_httpreceiver *)httpFactory->getInterface();
+
+	return get;
+}
+
+void ReleaseGet(api_httpreceiver *&get)
+{
+	if (!get)
+		return ;
+
+	if (!httpFactory && mod.service)
+		waServiceFactory *sf = mod.service->service_getServiceByGuid(httpreceiverGUID);
+
+	if (httpFactory)
+		httpFactory->releaseInterface(get);
+
+	get = 0;
+}
+
+
+#endif
+#define MAX_MULTICONNECTS 8
+
+class HTTPReader : public IDataReader
+{
+public:
+	HTTPReader(const char *url);
+	~HTTPReader();
+	size_t read(char *buf, size_t len);
+	bool iseof() { return !!m_eof; }
+	char *gettitle() { return m_title; }
+	char *geterror() { return m_err; }
+	bool canseek() { return m_content_length != 0xFFFFFFFF && m_accept_ranges && !m_meta_interval; }
+	int seek(unsigned __int64 newpos)
+	{
+		if (!canseek()) return 1;
+		doConnect((int)newpos);
+		return 0;
+	}
+unsigned __int64 getsize() { return m_content_length; }
+	char *getheader(char *header_name)
+	{
+		return m_get ? (char *)m_get->getheader(header_name) : NULL;
+	}
+private:
+
+	int serialconnect( int seekto , int timeout);
+	void doConnect(int seekto);
+	int getProxyInfo(const char *url, char *out);
+	char *m_url;
+	char *m_err;
+	char *m_title;
+	int m_eof;
+	int m_meta_init, m_meta_interval, m_meta_pos, m_meta_size, m_meta_buf_pos;
+	char m_meta_buf[4096];
+	int m_read_headers;
+	unsigned int m_content_length;
+	int m_accept_ranges;
+	int m_is_uvox;
+	int m_uvox_readpos;
+	int m_uvox_enough_bytes;
+	char proxybuf[8400], *proxy;
+
+	api_httpreceiver *m_get;
+
+	// this structure is allocated once, and freed once
+	struct
+	{
+		char *url; //pointers into m_url
+		// these two are only active temporarily.
+		api_httpreceiver *get;
+		char *error;
+	}
+	m_cons[MAX_MULTICONNECTS];
+	int m_numcons;
+	int m_newcons;
+	int m_serialized;
+	int	m_mstimeout;
+	int	m_contryptr;
+	int m_serialfailed;
+	int m_useaproxy;
+};
+
+HTTPReader::HTTPReader(const char *url)
+{
+	m_title = 0;
+	m_is_uvox = m_uvox_readpos = 0;
+	m_meta_init = m_meta_interval = m_meta_pos = m_meta_size = m_meta_buf_pos = 0;
+	m_meta_buf[0] = 0;
+	m_err = NULL;
+	m_eof = 0;
+	m_read_headers = 0;
+	m_content_length = 0xFFFFFFFF;
+	m_accept_ranges = 0;
+	m_get = NULL;
+	m_serialized = 0;
+	m_mstimeout = 0;
+	m_contryptr = 0;
+	m_newcons = 0;
+	m_serialfailed = 0;
+	m_useaproxy = 0;
+
+	// TCP multiconnect
+	// JF> using ; as a delimiter is vomit inducing and breaks a lot of other
+	//     code. I petition we use <> to delimit, and I'm making it do that.
+
+	m_numcons = 0;
+	m_url = _strdup(url);
+
+	int allowproxy = 1;
+	char *tmpurl = m_url;
+	while (m_numcons < MAX_MULTICONNECTS)
+	{
+		char *next = strstr( tmpurl, "<>" );
+		if ( next ) *next = '\0';
+
+		if (tmpurl[0])
+		{
+			m_cons[m_numcons].error = NULL;
+			m_cons[m_numcons].get = NULL;
+			m_cons[m_numcons++].url = tmpurl;
+			if (!_strnicmp(tmpurl, "uvox:", 5)) allowproxy = 0;
+			if (!_strnicmp(tmpurl, "order://", 8))
+			{
+				char *p = tmpurl + 8;
+				// serialized mctp
+				m_serialized = 1;
+				m_numcons--;
+				m_mstimeout = atoi(p);
+				if ( m_mstimeout < 1 )
+				{
+					m_serialized = 0;
+					m_mstimeout = 0;
+				}
+			}
+		}
+
+		if (!next) break;
+
+		tmpurl = next + 2;
+	}
+
+	memset(proxybuf, 0, sizeof(proxybuf));
+	proxy = NULL;
+	if (allowproxy && getProxyInfo(url, proxybuf))
+	{
+		proxy = strstr(proxybuf, "http=");
+		if (!proxy) proxy = proxybuf;
+		else
+		{
+			proxy += 5;
+			char *tp = strstr(proxy, ";");
+			if (tp) *tp = 0;
+		}
+	}
+	m_is_uvox = 0;
+
+	if ( m_serialized && m_numcons > 1 )  // sanity check
+	{
+		int rval = 0, i;
+		m_newcons = 1;
+		// walk the list, set the url such that m_cons[0].url points to each item. try to connect
+		// serialconnect returns error codes -1 on error, 0 on timeout, 1 on successfull connect
+		for ( i = 0; i < m_numcons; i++ )
+		{
+			if ( i )
+			{
+				m_cons[0].url = m_cons[i].url;
+			}
+			rval = serialconnect(0, m_mstimeout);
+			if ( rval == 1 ) break;
+		}
+		if ( rval < 1 )
+		{
+			// we didnt get a connection so...
+			m_serialfailed = 1;
+		}
+
+	}
+	else
+		doConnect(0);
+}
+
+
+void HTTPReader::doConnect(int seekto)
+{
+	ReleaseGet(m_get);
+	m_uvox_readpos = 0;
+
+	m_eof = 0;
+
+
+	int i;
+	for (i = 0; i < m_numcons; i++ )
+	{
+		free(m_cons[i].error);
+		m_cons[i].error = NULL;
+		ReleaseGet(m_cons[i].get);
+		m_cons[i].get = CreateGet();
+		if (!m_cons[i].get)
+			break;
+		m_cons[i].get->open(API_DNS_AUTODNS, 65536, (proxy && proxy[0]) ? proxy : NULL);
+#ifdef WINAMP_PLUGIN
+		m_cons[i].get->addheader("User-Agent:Winamp NSV Player/5.12 (ultravox/2.0)");
+#else
+ # ifdef WINAMPX
+		m_cons[i].get->addheader("User-Agent:" UNAGI_USER_AGENT " (ultravox/2.0)");
+#  else
+		m_cons[i].get->addheader("User-Agent:NSV Player/0.0 (ultravox/2.0)");
+#  endif
+#endif
+		m_cons[i].get->addheader("Accept:*/*");
+		m_cons[i].get->addheader("Connection:close");
+		m_cons[i].get->addheader("Ultravox-transport-type: TCP");
+
+		if (seekto)
+		{
+			char buf[64] = {0};
+			wsprintfA(buf, "Range:bytes=%d-", seekto);
+			m_cons[i].get->addheader(buf);
+		}
+		else
+			m_cons[i].get->addheader("icy-metadata:1");
+
+		m_cons[i].get->connect(m_cons[i].url, !!seekto);
+	}
+	m_uvox_enough_bytes = 1;
+}
+
+HTTPReader::~HTTPReader()
+{
+	ReleaseGet(m_get);
+	free(m_title);
+	free(m_err);
+	free(m_url);
+
+	int i;
+	for (i = 0; i < m_numcons; i++)
+	{
+		ReleaseGet(m_cons[i].get);
+		free(m_cons[i].error);
+	}
+}
+
+int HTTPReader::serialconnect(int seekto , int timeout)
+{
+
+	ReleaseGet(m_get);
+	m_uvox_readpos = 0;
+
+	m_eof = 0;
+
+	int64_t mythen, mynow , myref;
+	LARGE_INTEGER then, now, ref;
+
+
+	QueryPerformanceFrequency( &ref);
+	myref = ref.QuadPart;
+
+
+	QueryPerformanceCounter( &then );
+	mythen = then.QuadPart;
+
+
+	int timer = 0;
+
+	int i = 0;
+
+	{
+		ReleaseGet(m_cons[i].get);
+		m_cons[i].get = CreateGet();
+		if (m_cons[i].get == NULL)
+			return 0;
+		m_cons[i].get->open(API_DNS_AUTODNS, 65536, (proxy && proxy[0]) ? proxy : NULL);
+#ifdef WINAMP_PLUGIN
+		m_cons[i].get->addheader("User-Agent:Winamp NSV Player/5.12 (ultravox/2.0)");
+#else
+# ifdef WINAMPX
+		m_cons[i].get->addheader("User-Agent:" UNAGI_USER_AGENT " (ultravox/2.0)");
+#  else
+		m_cons[i].get->addheader("User-Agent:NSV Player/0.0 (ultravox/2.0)");
+#  endif
+#endif
+		m_cons[i].get->addheader("Accept:*/*");
+		m_cons[i].get->addheader("Connection:close");
+		m_cons[i].get->addheader("Ultravox-transport-type: TCP");
+
+		if (seekto)
+		{
+			char buf[64] = {0};
+			wsprintfA(buf, "Range:bytes=%d-", seekto);
+			m_cons[i].get->addheader(buf);
+		}
+		else m_cons[i].get->addheader("icy-metadata:1");
+
+		m_cons[i].get->connect(m_cons[i].url, !!seekto);
+	}
+	m_uvox_enough_bytes = 1;
+
+	int ret, status;
+
+	if (!m_get)
+	{
+		if (m_err) return 0;
+		int i;
+		int found = 0;
+		i = 0;
+		while ( timer < timeout )
+		{
+			if (!m_cons[i].get) return 0;
+			found = 1;
+
+			QueryPerformanceCounter( &now );
+			mynow = now.QuadPart;
+
+			float profiletime = (float)(mynow - mythen);
+			profiletime /= myref;
+			profiletime *= 1000.0;
+			timer = (int) profiletime;
+
+			ret = m_cons[i].get->run();
+			status = m_cons[i].get->get_status();
+
+			if (ret < 0 || status < 0)
+			{
+				const char *t = m_cons[i].get->geterrorstr();
+				if (t)
+				{}
+				ReleaseGet(m_cons[i].get);
+				break;
+			}
+
+			if ( status > 0 )
+			{
+				int code = m_cons[i].get->getreplycode();
+				if ( code < 200 || code > 299 )
+				{
+					ReleaseGet(m_cons[i].get);
+					//wsprintf( m_cons[i].error, "Error: Server returned %d", code );
+					break;
+				}
+				else
+				{
+					// we're in good shape, make our getter current, and delete all the gay ones
+					ReleaseGet(m_get); // just in case, probably zero anyway
+					m_get = m_cons[i].get;
+					m_cons[i].get = NULL;
+
+					// trash i here, but we are breaking anyway :)
+					/* for (i = 0; i < m_numcons; i++)
+					    {
+						  delete m_cons[i].get;
+					  m_cons[i].get = NULL;
+					 free( m_cons[i].error );
+					 m_cons[i].error = NULL;
+					 }*/
+					break;
+				}
+			}
+#ifdef _WIN32
+			Sleep(1);
+#else
+			usleep(1000);
+#endif
+		} // while
+		if ( timer > timeout )
+		{
+			ReleaseGet(m_cons[i].get);
+			ReleaseGet(m_get);
+			return 0;
+		}
+
+
+		if (!m_get)
+		{
+			return 0;
+		}
+	}
+	if ( m_get ) return 1;
+	else return 0;
+}
+
+
+size_t HTTPReader::read(char *buffer, size_t len)
+{
+	int ret, status;
+
+	if (!m_get)
+	{
+		if (m_err) return 0;
+		int i;
+		int found = 0;
+		for (i = 0; !m_get && i < m_numcons; i++)
+		{
+			if (!m_cons[i].get) continue;
+			found = 1;
+
+			ret = m_cons[i].get->run();
+			status = m_cons[i].get->get_status();
+
+			if (ret < 0 || status < 0)
+			{
+				const char *t = m_cons[i].get->geterrorstr();
+				if (t)
+				{
+					free(m_cons[i].error);
+					m_cons[i].error = _strdup( t );
+				}
+				ReleaseGet(m_cons[i].get);
+
+			}
+
+			if ( status > 0 )
+			{
+				int code = m_cons[i].get->getreplycode();
+				if ( code < 200 || code > 299 )
+				{
+					ReleaseGet(m_cons[i].get);
+					m_cons[i].get = NULL;
+
+					free(m_cons[i].error);
+					m_cons[i].error = (char *)malloc( 100 );
+					wsprintfA( m_cons[i].error, "Error: Server returned %d", code );
+				}
+				else
+				{
+					// we're in good shape, make our getter current, and delete all the gay ones
+					ReleaseGet(m_get); // just in case, probably zero anyway
+					m_get = m_cons[i].get;
+					m_cons[i].get = NULL;
+
+					// trash i here, but we are breaking anyway :)
+					for (i = 0; i < m_numcons; i++)
+					{
+						ReleaseGet(m_cons[i].get);
+						free( m_cons[i].error );
+						m_cons[i].error = NULL;
+					}
+					break; // exit loop of connections
+				}
+			}
+		} // loop of connections
+
+		if (!found) // out of attempted connections heh
+		{
+			free( m_err );
+			if (m_numcons > 1)
+			{
+				size_t size = 0;
+				for (i = 0; i < m_numcons; i++)
+					if ( m_cons[i].error ) size += strlen( m_cons[i].error ) + 1;
+
+				m_err = (char *)malloc(size + 100);
+				wsprintfA( m_err, "No Valid Multiconnect URLs (%d);", m_numcons );
+				for (i = 0; i < m_numcons; i++)
+				{
+					strcat( m_err, m_cons[i].error );
+					strcat( m_err, ";" );
+					free(m_cons[i].error);
+					m_cons[i].error = NULL;
+
+				}
+			}
+			else
+			{
+				m_err = m_cons[0].error;
+				m_cons[0].error = NULL;
+				if (!m_err) m_err = _strdup("Connection error (Invalid URL?)");
+			}
+		}
+		if (!m_get) return 0;
+	}
+
+	ret = m_get->run();
+	status = m_get->get_status();
+
+	if (ret > 0 && (!m_get->bytes_available() || !m_uvox_enough_bytes) && status > 1)
+	{
+		m_eof = 1;
+	}
+
+	if (ret < 0 || status < 0)
+	{
+		const char *t = m_get->geterrorstr();
+		if (t)
+		{
+			free( m_err );
+			m_err = (char *)malloc( strlen( t) + 16 );
+			wsprintfA( m_err, "Error: %s", t );
+			return 0;
+		}
+	}
+
+	if (status > 0)
+	{
+		if (!m_read_headers)
+		{
+			if (status > 1)
+			{
+				const char *v = m_get->getheader("Content-Length");
+				if (v) m_content_length = atoi(v);
+				v = m_get->getheader("Accept-Ranges");
+				if (v) while (v && *v)
+					{
+						if (!_strnicmp(v, "bytes", 5))
+						{
+							m_accept_ranges = 1;
+							break;
+						}
+						v++;
+					}
+				v = m_get->getheader("icy-metaint");
+				if (v)
+				{
+					m_meta_interval = atoi(v);
+				}
+				if (!m_title)
+				{
+					v = m_get->getheader("icy-name");
+					if (v)
+						m_title = _strdup(v);
+				}
+#ifdef WINAMP_PLUGIN
+				extern void process_url(char *url);
+				v = m_get->getheader("icy-url");
+				if (v && !strstr(v, "shoutcast.com"))
+				{
+					char *p = (char *)v; while (p && *p && *p == ' ') p++;
+					process_url(p);
+				}
+#endif
+
+				v = m_get->getheader("content-type");
+				if (v && !_stricmp(v, "misc/ultravox"))
+				{
+					v = m_get->getheader("ultravox-max-msg");
+					if (v) m_is_uvox = atoi(v);
+					if (!m_is_uvox) m_is_uvox = 16000;
+				}
+				if (!m_title)
+				{
+					v = m_get->getheader("content-disposition");
+					if (v) v = strstr(v, "filename=");
+					if (v)
+					{
+						m_title = _strdup(v + 9);
+					}
+				}
+				m_read_headers = 1;
+			}
+		}
+
+		size_t l = m_get->bytes_available();
+		if (m_is_uvox)
+		{
+		again:
+			if (l >= 6)
+			{
+				unsigned char buf[32768*2] = {0};
+				m_get->peek_bytes((char *)buf, 6);
+				if (buf[0] != 0x5A)
+				{
+					l--;
+					m_get->get_bytes((char *)buf, 1);
+					goto again;
+				}
+				int resqos = buf[1];
+				int classtype = (buf[2] << 8) | buf[3];
+				int msglen = (buf[4] << 8) | buf[5];
+				if (msglen > m_is_uvox) // length is too long
+				{
+					m_get->get_bytes((char *)buf, 1);
+					l--;
+					goto again;
+				}
+				if (msglen + 7 <= (int)l)
+				{
+					m_uvox_enough_bytes = 1;
+
+					m_get->peek_bytes((char *)buf, msglen + 7);
+					if (buf[msglen + 6])
+					{
+						m_get->get_bytes((char *)buf, 1);
+						l--;
+						goto again;
+					}
+					if (classtype == 0x7777) // take any data for now, ignore all other frames
+					{
+						l = msglen - m_uvox_readpos;
+						if (l > len) l = len;
+						memcpy(buffer, buf + 6 + m_uvox_readpos, l);
+						m_uvox_readpos += (int)l;
+
+						if (m_uvox_readpos >= msglen)
+						{
+							m_uvox_readpos = 0;
+							m_get->get_bytes((char *)buf, msglen + 7);
+
+						}
+						return l;
+
+#ifdef WINAMP_PLUGIN
+
+					}
+					else if ( classtype == 0x3001 )
+					{
+						extern void process_metadata(char *buf, int size);
+						m_get->get_bytes((char *)buf, msglen + 7);
+						process_metadata((char*)buf + 6, msglen + 1);
+#endif
+
+					}
+					else
+					{
+						m_get->get_bytes((char *)buf, msglen + 7);
+					}
+				}
+				else
+				{
+					m_uvox_enough_bytes = 0;
+				}
+			}
+			return 0;
+		}
+		else
+		{
+			if (l > len) l = len;
+			m_get->get_bytes(buffer, (int)l);
+
+			if (m_meta_interval)
+			{
+				int x = (int)l;
+				unsigned char *buf = (unsigned char *)buffer;
+				if (m_meta_size) // already in meta block
+				{
+					int len = min(x, m_meta_size - m_meta_buf_pos);
+
+					memcpy(m_meta_buf + m_meta_buf_pos, buf, len);
+					m_meta_buf_pos += len;
+
+					if (m_meta_buf_pos == m_meta_size)
+					{
+						//	if(metacb) metacb->metaDataReader_onData(m_meta_buf,m_meta_size);
+						m_meta_buf_pos = 0;
+						m_meta_size = 0;
+						m_meta_pos = 0;
+					}
+
+					x -= len;
+					if (x) memcpy(buf, buf + len, x);
+				}
+				else if (m_meta_pos + x > m_meta_interval) // block contains meta data somewhere in it, and we're not alreayd reading a block
+				{
+					int start_offs = m_meta_interval - m_meta_pos;
+					int len;
+					m_meta_size = ((unsigned char *)buf)[start_offs] * 16;
+
+					len = min(x - start_offs - 1, m_meta_size);
+
+					if (len) memcpy(m_meta_buf, buf + start_offs + 1, len);
+					m_meta_buf_pos = len;
+
+					if (m_meta_buf_pos == m_meta_size) // full read of metadata successful
+					{
+						x -= m_meta_size + 1;
+						if (x > start_offs) memcpy(buf + start_offs, buf + start_offs + 1 + m_meta_size, x - start_offs);
+#ifdef WINAMP_PLUGIN
+						extern void process_metadata(char *buf, int size);
+						process_metadata(m_meta_buf, m_meta_size);
+#endif
+						//if(metacb) metacb->metaDataReader_onData(m_meta_buf,m_meta_size);
+						m_meta_buf_pos = 0;
+						m_meta_pos = -start_offs;
+						m_meta_size = 0;
+					}
+					else
+					{
+						x = start_offs; // otherwise, there's only the first block of data
+					}
+				}
+				if (x > 0)
+				{
+					m_meta_pos += x;
+				}
+				l = x;
+			} // end of poopie metadata
+		} // !uvox
+
+#if 0
+		{
+			FILE *fh = fopen("c:\\dump.nsv", "ab");
+			fwrite(buffer, 1, l, fh);
+			fclose(fh);
+		}
+#endif
+
+		return l;
+	}
+	return 0;
+}
+
+static void parseURL(char *url, char *lp, char *host, int *port, char *req)
+{
+	char *p, *np;
+	/*  if (_strnicmp(url,"http://",4) &&
+		    _strnicmp(url,"icy://",6) &&
+		    _strnicmp(url,"sc://",6) &&
+		    _strnicmp(url,"shoutcast://",12)) return;
+	      */
+	np = p = strstr(url, "://");
+	if (!np) np = (char*)url;
+	else np += 3;
+	if (!p) p = (char*)url;
+	else p += 3;
+
+	while (np && *np != '/' && *np) *np++;
+	if (np && *np)
+	{
+		lstrcpynA(req, np, 2048);
+		*np++ = 0;
+	}
+	else strcpy(req, "/");
+	np = p;
+	while (np && *np != '@' && *np) np++;
+	if (np && *np)
+	{
+		*np++ = 0;
+		lstrcpynA(lp, p, 256);
+		p = np;
+	}
+	else lp[0] = 0;
+	np = p;
+	while (np && *np != ':' && *np) np++;
+	if (*np)
+	{
+		*np++ = 0;
+		*port = atoi(np);
+	}
+	else *port = 80;
+	lstrcpynA(host, p, 256);
+}
+
+int HTTPReader::getProxyInfo(const char *url, char *out)
+{
+#ifndef WINAMPX
+	char INI_FILE[MAX_PATH] = {0};
+	char *p;
+	GetModuleFileNameA(NULL, INI_FILE, sizeof(INI_FILE));
+	p = INI_FILE + strlen(INI_FILE);
+	while (p >= INI_FILE && *p != '.') p--;
+	strcpy(++p, "ini");
+	GetPrivateProfileStringA("Winamp", "proxy", "", out, 8192, INI_FILE);
+	return !!out[0];
+#else
+	DWORD v = 0;
+	HKEY hKey;
+
+
+	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\AOL\\Unagi", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
+	{
+		DWORD l = 4;
+		DWORD t;
+		if (RegQueryValueEx(hKey, "ProxyEnable", NULL, &t, (unsigned char *)&v, &l) == ERROR_SUCCESS && t == REG_DWORD)
+		{
+			if ( v != 2 )
+			{
+				l = 8192;
+				if (RegQueryValueEx(hKey, "ProxyServer", NULL, &t, (unsigned char *)out, &l ) != ERROR_SUCCESS || t != REG_SZ)
+				{
+					v = 0;
+					*out = 0;
+				}
+			}
+			else return 0;
+		}
+		else v = 0;
+		out[512 - 1] = 0;
+		RegCloseKey(hKey);
+	}
+	if ( !v && m_useaproxy )
+	{
+		char blah[8192] = "";
+		lstrcpyn(blah, url, 8192);
+		char plp[512] = {0};
+		char phost[512] = {0};
+		int pport = 80;
+		char pthereq[1024] = {0};
+		parseURL(blah, plp, phost, &pport, pthereq);
+		v = ResolvProxyFromURL(url, phost, out);
+		if ( v < 0 ) v = 0;  // error getting proxy
+	}
+	if ( v > 0)
+	{
+		char prox[1024] = {0};
+		wsprintf(prox, "PROXY: %s", out);
+		SendMetadata(prox, 1);
+	}
+	return v;
+#endif
+}
+
+
+
+class Win32FileReader : public IDataReader
+{
+public:
+	Win32FileReader(HANDLE file) { m_hFile = file; m_eof = 0; m_err = NULL; }
+	~Win32FileReader() { CloseHandle(m_hFile); }
+	size_t read(char *buf, size_t len)
+	{
+		DWORD ob = 0;
+		if (!len) return 0;
+		if (!ReadFile(m_hFile, buf, (DWORD)len, &ob, NULL))
+		{
+			m_err = "Error calling ReadFile()!";
+			return 0;
+		}
+		else if (!ob) m_eof = true;
+		return ob;
+	}
+bool iseof() { return m_eof; }
+	bool canseek() { return 1; }
+	int seek(uint64_t newpos)
+	{
+		LARGE_INTEGER li;
+		li.QuadPart = newpos;
+		li.LowPart = SetFilePointer (m_hFile, li.LowPart, &li.HighPart, SEEK_SET);
+
+		if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
+		{
+			li.QuadPart = -1;
+		}
+
+		return li.QuadPart== ~0;
+	}
+
+	uint64_t getsize()
+	{
+		LARGE_INTEGER position;
+		position.QuadPart=0;
+		position.LowPart = GetFileSize(m_hFile, (LPDWORD)&position.HighPart); 	
+
+		if (position.LowPart == INVALID_FILE_SIZE && GetLastError() != NO_ERROR)
+			return INVALID_FILE_SIZE;
+		else
+			return position.QuadPart;
+	}
+
+	char *geterror() { return m_err; }
+private:
+	HANDLE m_hFile;
+	bool m_eof;
+	char *m_err;
+};
+
+
+#define VAR_TO_FPOS(fpos, var) (fpos) = (var)
+#define FPOS_TO_VAR(fpos, typed, var) (var) = (typed)(fpos)
+class FileReader : public IDataReader
+{
+public:
+	FileReader(FILE *file) { fp = file;  m_err = NULL; }
+	~FileReader() { fclose(fp); }
+	size_t read(char *buf, size_t len)
+	{
+		size_t ob;
+		if (!len) return 0;
+		ob = fread(buf, 1, len, fp);
+		if (!ob && ferror(fp))
+		{
+			m_err = "Error calling fread()!";
+			return 0;
+		}
+		return ob;
+	}
+	bool iseof() { return !!feof(fp); }
+	bool canseek() { return 1; }
+	int seek(uint64_t newpos)
+	{
+		fpos_t pos= newpos;
+		VAR_TO_FPOS(pos, newpos);
+		return fsetpos(fp, &pos);
+	}
+
+	unsigned __int64 getsize()
+	{
+		struct stat s;
+		if (fstat(fileno(fp), &s) < 0) 
+		{ 
+			m_err = "Error calling fread()!";
+			return 0;
+		}
+		return s.st_size;
+	}
+
+	char *geterror() { return m_err; }
+private:
+	FILE *fp;
+	char *m_err;
+};
+
+
+IDataReader *CreateReader(const char *url)
+{
+	if (strstr(url, "://")) return new HTTPReader(url);
+#ifdef _WIN32
+	HANDLE hFile = CreateFileA(url, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+	                          OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+	if (hFile != INVALID_HANDLE_VALUE)
+		return new Win32FileReader(hFile);
+#else
+	FILE *fp = fopen(url, "r");
+	if (fp)
+		return new FileReader(fp);
+#endif
+	return NULL;
+}
+
diff --git a/Src/nsv/nsvplay/resource.h b/Src/nsv/nsvplay/resource.h
new file mode 100644
index 00000000..57b058a7
--- /dev/null
+++ b/Src/nsv/nsvplay/resource.h
@@ -0,0 +1,18 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by nsvplay.rc
+//
+#define IDD_ABOUT                       101
+#define IDB_BITMAP1                     102
+#define IDC_VERSION                     1000
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        103
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1001
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/Src/nsv/nsvplay/subtitles.cpp b/Src/nsv/nsvplay/subtitles.cpp
new file mode 100644
index 00000000..e599bf14
--- /dev/null
+++ b/Src/nsv/nsvplay/subtitles.cpp
@@ -0,0 +1,215 @@
+#include "subtitles.h"
+
+Subtitles::Subtitles(const char *filename)
+{
+  m_frame_based=0;
+  m_last_sub=-1;
+  m_font_size_mod=0;
+
+#ifdef SUBTITLES_READER
+  if(!filename) return;
+
+  IDataReader *file_reader=CreateReader(filename);
+  if(file_reader) {
+    char *text=NULL;
+    int textpos=0;
+    int allocsize=0;
+    char buf[1024] = {0};
+    unsigned aborttime=GetTickCount()+20000;
+    for (;;)
+    {
+      int l=file_reader->read(buf,1024);
+      if (l <= 0) 
+      {
+        if (file_reader->iseof()) break;
+        if (file_reader->geterror() || GetTickCount() > aborttime) 
+        {
+          free(text);
+          return;
+        }
+        Sleep(100);
+      }
+      else
+      {
+        if (textpos+l+1 >= allocsize)
+        {
+          allocsize = textpos+l+1+8192;
+          text=(char*)realloc(text,allocsize);
+        }
+        memcpy(text+textpos,buf,l);
+        textpos+=l;
+      }
+    }
+    if (text) {
+      text[textpos]=0;
+      //fucko: check for case
+      if(strstr(filename,".srt")) decodeSrtFile(text);
+      else if(strstr(filename,".sub")) decodeSubFile(text);
+      free(text);
+    }
+  }
+  delete(file_reader);
+#endif
+}
+
+#ifdef SUBTITLES_READER
+void Subtitles::decodeSrtFile(char *text) {
+  // parse subtitle file (.srt format)
+  char *p=text;
+
+  //for(int i=0;;i++) {
+  while(1) {
+    unsigned int time_start,time_end;
+
+    // parse title nb
+    char *p2=p;
+    while(*p2 && *p2!='\n') p2++;
+    *p2++=0;
+    //if(atoi(p)!=i+1) break;
+    if(atoi(p)<=0) break;
+      
+    // parse start time
+    p=p2;
+    while(*p2 && *p2!=' ') p2++;
+    *p2++=0;
+    time_start=getTimeFromSrtText(p);
+
+    // parse "-->"
+    while(*p2 && *p2!=' ') p2++;
+    p2++;
+    
+    // parse end time
+    p=p2;
+    while(*p2 && *p2!='\n') p2++;
+    *p2++=0;
+    time_end=getTimeFromSrtText(p);
+
+    // parse text
+    p=p2;
+    while(*p2 && !(*p2=='\r' || *p=='\n')) {
+      while(*p2 && *p2!='\n') p2++;
+      p2++;
+    }
+    *p2++=0;
+
+    //remove trailing CR
+    {
+      int l=strlen(p);
+      if(l) {
+        if(p[l-1]=='\r' || p[l-1]=='\n') p[l-1]=0;
+      }
+    }
+
+    m_subs.put(new SubsItem(time_start,time_end,p));
+
+    if(*p2=='\n') p2++;
+    p=p2;
+  }
+  m_frame_based=0;
+}
+
+unsigned int Subtitles::getTimeFromSrtText(const char *text) {
+  int hours,mins,secs,mills;
+  const char *p=text;
+  hours=atoi(p);
+  while(*p && *p!=':') p++;
+  p++;
+  mins=atoi(p);
+  while(*p && *p!=':') p++;
+  p++;
+  secs=atoi(p);
+  while(*p && *p!=',') p++;
+  p++;
+  mills=atoi(p);
+  return mills+(secs*1000)+(mins*60000)+(hours*60*60000);
+}
+
+void Subtitles::decodeSubFile(char *text)
+{
+  char *p=text;
+  while(*p=='{') {
+    int framestart,frameend;
+    p++;
+    char *p2=p;
+    while(*p2 && *p2!='}') p2++;
+    *p2++=0;
+    framestart=atoi(p);
+
+    p2+=1;
+    p=p2;
+    while(*p2 && *p2!='}') p2++;
+    *p2++=0;
+    frameend=atoi(p);
+
+    p=p2;
+    while(*p2 && *p2!='\r' && *p2!='\n') {
+      //replace pipes with CR
+      if(*p2=='|') *p2='\n';
+      p2++;
+    }
+    *p2++=0;
+    
+    m_subs.put(new SubsItem(framestart,frameend,p));
+
+    if(*p2=='\n') p2++;
+    p=p2;
+  }
+  m_frame_based=1;
+}
+#endif
+
+SubsItem *Subtitles::getSubtitle(unsigned int time, unsigned int frame)
+{
+  unsigned int ref=m_frame_based?frame:time;
+
+  //check with lastsub
+  if(m_last_sub!=-1) {
+    SubsItem *item=m_subs.get(m_last_sub);
+    if(ref>=item->timestart && ref<=item->timeend) 
+    {
+      item->fontSize=item->origFontSize+m_font_size_mod;
+      return item;
+    }
+    SubsItem *item2=m_subs.get(m_last_sub+1);
+    if(item2) {
+      if(ref>=item->timeend && ref<=item2->timestart) return NULL;
+      if(ref>=item2->timestart && ref<=item2->timeend) {
+        m_last_sub++;
+        item2->fontSize=item2->origFontSize+m_font_size_mod;
+        return item2;
+      }
+    }
+  } 
+
+  int l= (int)m_subs.getlen();
+  for(int i=0;i<l;i++) {
+    SubsItem *item=m_subs.get(i);
+    if(ref<item->timestart) break;
+    if(ref>=item->timestart && ref<=item->timeend) {
+      m_last_sub=i;
+      item->fontSize=item->origFontSize+m_font_size_mod;
+      return item;
+    }
+  }
+  m_last_sub=-1;
+  return NULL;
+}
+
+void Subtitles::addSubtitlePacket(SUBTITLE_INFO *sti) 
+{
+  m_frame_based=1; //FUCKO: put this in subsitem struct
+  SubsItem *i=new SubsItem(sti->start_frame,sti->end_frame,sti->utf8_text);
+  i->xPos=sti->xPos;
+  i->yPos=sti->yPos;
+  i->colorBlue=sti->colorBlue;
+  i->colorGreen=sti->colorGreen;
+  i->colorRed=sti->colorRed;
+  i->extraDataSize=sti->extraDataSize;
+  i->origFontSize=sti->fontSize;
+  if(sti->extraDataSize) {
+    i->extraData=malloc(sti->extraDataSize);
+    memcpy((void *)i->extraData,sti->extraData,sti->extraDataSize);
+  }
+  i->muxed_subtitle=1;
+  m_subs.put(i);
+}
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/subtitles.h b/Src/nsv/nsvplay/subtitles.h
new file mode 100644
index 00000000..f4951a23
--- /dev/null
+++ b/Src/nsv/nsvplay/subtitles.h
@@ -0,0 +1,62 @@
+#ifndef NSVPLAY_SUBTITLES_H
+#define NSVPLAY_SUBTITLES_H
+
+#include "main.h"
+#include "../nsvbs.h"
+
+class SubsItem {
+public:
+  SubsItem(unsigned int ptimestart, unsigned int ptimeend, const char *ptext) :
+      timestart(ptimestart) , timeend(ptimeend) { 
+        text=_strdup(ptext);
+        xPos=128;
+        yPos=255;
+        colorRed=colorGreen=colorBlue=0xff;
+        extraDataSize=0;
+        extraData=0;
+        muxed_subtitle=0;
+        fontSize=origFontSize=0;
+      }
+  ~SubsItem() { 
+    free((void*)text); 
+    if(extraDataSize) free((void *)extraData);
+  }
+
+  unsigned int timestart;
+  unsigned int timeend; 
+  const char *text;
+
+  unsigned char xPos, yPos;
+  unsigned char colorRed, colorGreen, colorBlue;
+  int extraDataSize;
+  const void *extraData;
+
+  int muxed_subtitle; //so we free it when we seek/display
+
+  int fontSize;
+
+  int origFontSize;
+};
+
+class Subtitles {
+public:
+  Subtitles(const char *filename);
+
+  SubsItem *getSubtitle(unsigned int time, unsigned int frame); // time in ms
+  void addSubtitlePacket(SUBTITLE_INFO *sti);
+
+  void setFontSizeModifier(int size) { m_font_size_mod=size; }
+  
+private:
+  void decodeSrtFile(char *text);
+  unsigned int getTimeFromSrtText(const char *text);
+
+  void decodeSubFile(char *text);
+
+  ClassList<SubsItem> m_subs;
+  int m_frame_based;
+  int m_last_sub;
+  int m_font_size_mod;
+};
+
+#endif
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/vid_ddraw.cpp b/Src/nsv/nsvplay/vid_ddraw.cpp
new file mode 100644
index 00000000..b4c0af68
--- /dev/null
+++ b/Src/nsv/nsvplay/vid_ddraw.cpp
@@ -0,0 +1,865 @@
+#include "video.h"
+#include <multimon.h>
+#include "subtitles.h"
+
+#define INIT_DIRECTDRAW_STRUCT(x) (ZeroMemory(&x, sizeof(x)), x.dwSize=sizeof(x))
+
+DDrawVideoOutput::DDrawVideoOutput() {
+  lpDD=NULL;
+  lpddsOverlay=NULL;
+  lastresizerect.bottom=0;
+  lastresizerect.top=0;
+  lastresizerect.left=0;
+  lastresizerect.right=0;
+
+  lpddsPrimary=NULL;
+  lpddsClipper=NULL;
+  lpddsSTTemp=NULL;
+  is_fullscreen=0;
+  m_parent=NULL;
+  initing=false;
+  needchange=0;
+  m_palette=NULL;
+  m_lastsubtitle=NULL;
+  sttmp_w=sttmp_h=0;
+  subFont=NULL;
+  m_sub_needremeasure=0;
+  m_fontsize=0;
+  memset(&winRect,0,sizeof(winRect));
+}
+
+DDrawVideoOutput::~DDrawVideoOutput() {
+//  LPDIRECTDRAWSURFACE o=lpddsOverlay;
+  lpddsOverlay=NULL;
+//  if(o) o->Release();
+ // if (lpddsSTTemp) lpddsSTTemp->Release();
+  //if(lpddsPrimary) lpddsPrimary->Release();
+//  if(lpddsClipper) lpddsClipper->Release();
+  if (lpDD) lpDD->Release();	// BU added NULL check in response to talkback
+  if(subFont) DeleteObject(subFont);
+  if (is_fullscreen) removeFullScreen();
+}
+
+void DDrawVideoOutput::drawSubtitle(SubsItem *item)
+{
+  m_lastsubtitle=item;
+  m_sub_needremeasure=1;
+}
+
+int DDrawVideoOutput::create(VideoOutput *parent, int w, int h, unsigned int ptype, int flipit, double aspectratio) {
+  m_lastsubtitle=NULL;
+  type=ptype;
+  width=w;
+  height=h;
+  flip=flipit;
+  m_parent=parent;
+
+  initing=true;
+  HWND hwnd=parent->getHwnd();
+
+  if (lpDD) lpDD->Release();
+  lpDD=NULL;
+
+  update_monitor_coords(parent);
+
+  if(!m_found_devguid) DirectDrawCreate(NULL,&lpDD,NULL);
+  else DirectDrawCreate(&m_devguid,&lpDD,NULL);
+
+  if(!lpDD) {
+    initing=false;
+    return 0;
+  }
+  
+  lpDD->SetCooperativeLevel(hwnd,DDSCL_NOWINDOWCHANGES|DDSCL_NORMAL);
+
+  DDSURFACEDESC   ddsd;
+  INIT_DIRECTDRAW_STRUCT(ddsd);
+  ddsd.dwFlags = DDSD_CAPS;
+  ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+  HRESULT ddrval = lpDD->CreateSurface(&ddsd, &lpddsPrimary, NULL );
+
+  HRESULT v=-1;
+  DDSURFACEDESC DDsd={sizeof(DDsd),};
+  lpddsPrimary->GetSurfaceDesc(&ddsd);
+  DDsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT; //create the surface at screen depth
+	DDsd.dwWidth=w;
+	DDsd.dwHeight=h;
+	DDsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
+	if (parent->vid_ddraw) v=lpDD->CreateSurface(&DDsd, &lpddsOverlay, NULL);
+  if(!parent->vid_ddraw || FAILED(v)) {
+    // fall back to system memory if video mem doesn't work
+    DDsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
+  	v=lpDD->CreateSurface(&DDsd, &lpddsOverlay, NULL);
+  }
+  if(FAILED(v)) {
+    // this video card sucks then :)
+    lpddsOverlay=NULL;
+    initing=false;
+    return 0;
+  }
+
+  // get the depth
+  m_depth=8;
+  INIT_DIRECTDRAW_STRUCT(m_ddpf);
+  if(lpddsOverlay->GetPixelFormat(&m_ddpf)>=0) {
+    m_depth=m_ddpf.dwRGBBitCount;
+    if (m_depth==16 && m_ddpf.dwGBitMask==0x03e0) m_depth=15;
+  }
+
+  lpDD->CreateClipper(0,&lpddsClipper,NULL);
+  lpddsClipper->SetHWnd(0,hwnd);
+  lpddsPrimary->SetClipper(lpddsClipper);
+  initing=false;
+  return 1;
+}
+
+int DDrawVideoOutput::onPaint(HWND hwnd, HDC hdc) {
+  return 0;
+}
+
+void DDrawVideoOutput::displayFrame(const char *buf, int size, int time) {
+  DDSURFACEDESC dd={sizeof(dd),};
+  if (m_parent->vid_vsync) lpDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN,0);
+  HRESULT result;
+  if ((result=lpddsOverlay->Lock(NULL,&dd,DDLOCK_WAIT,NULL)) != DD_OK) {
+    needchange=1;
+    return;
+  }
+  if(type==NSV_MAKETYPE('Y','V','1','2')) {
+    const YV12_PLANES *planes=(YV12_PLANES *)buf;
+    // convert yv12 to rgb
+    int bytes = m_depth >> 3; 
+    if(m_depth==15) bytes=2;
+    int i, j, y00, y01, y10, y11, u, v;
+	  unsigned char *pY = (unsigned char *)planes->y.baseAddr;
+    unsigned char *pU = (unsigned char *)planes->u.baseAddr;
+	  unsigned char *pV = (unsigned char *)planes->v.baseAddr;
+	  unsigned char *pOut = (unsigned char*)dd.lpSurface;
+   	const int rvScale = 91881;
+    const int guScale = -22553;
+    const int gvScale = -46801;
+    const int buScale = 116129;
+    const int yScale  = 65536;
+    int addOut=dd.lPitch*2-width*bytes;
+    int yrb=planes->y.rowBytes;
+    int addL=dd.lPitch;
+
+    /* LIMIT: convert a 16.16 fixed-point value to a byte, with clipping. */
+    #define LIMIT(x) ((x)>0xffffff?0xff: ((x)<=0xffff?0:((x)>>16)))
+
+    if(flip) {
+      pOut+=(dd.lPitch)*(height-1);
+      addOut=-dd.lPitch*2 - width*bytes;
+      addL=-addL;
+    }
+
+    for (j = 0; j <= height - 2; j += 2) {
+      for (i = 0; i <= width - 2; i += 2) {
+			  y00 = *pY;
+			  y01 = *(pY + 1);
+			  y10 = *(pY + yrb);
+			  y11 = *(pY + yrb + 1);
+			  u = (*pU++) - 128;
+			  v = (*pV++) - 128;
+
+        {
+      	  int r, g, b;
+
+	        g = guScale * v + gvScale * u;
+    		  r = buScale * v;
+    		  b = rvScale * u;
+
+	        y00 *= yScale; y01 *= yScale;
+	        y10 *= yScale; y11 *= yScale;
+
+          switch(m_depth) {
+          case 15:
+            {
+              unsigned short *rgb=(unsigned short *)pOut;
+              rgb[0]=((LIMIT(r+y00)>>3)<<10)|((LIMIT(g+y00)>>3)<<5)|(LIMIT(b+y00)>>3);
+              rgb[1]=((LIMIT(r+y01)>>3)<<10)|((LIMIT(g+y01)>>3)<<5)|(LIMIT(b+y01)>>3);
+              rgb+=addL/2;
+              rgb[0]=((LIMIT(r+y10)>>3)<<10)|((LIMIT(g+y10)>>3)<<5)|(LIMIT(b+y10)>>3);
+              rgb[1]=((LIMIT(r+y11)>>3)<<10)|((LIMIT(g+y11)>>3)<<5)|(LIMIT(b+y11)>>3);
+            }
+            break;
+          case 16:
+            {
+              unsigned short *rgb=(unsigned short *)pOut;
+              rgb[0]=((LIMIT(r+y00)>>3)<<11)|((LIMIT(g+y00)>>2)<<5)|(LIMIT(b+y00)>>3);
+              rgb[1]=((LIMIT(r+y01)>>3)<<11)|((LIMIT(g+y01)>>2)<<5)|(LIMIT(b+y01)>>3);
+              rgb+=addL/2;
+              rgb[0]=((LIMIT(r+y10)>>3)<<11)|((LIMIT(g+y10)>>2)<<5)|(LIMIT(b+y10)>>3);
+              rgb[1]=((LIMIT(r+y11)>>3)<<11)|((LIMIT(g+y11)>>2)<<5)|(LIMIT(b+y11)>>3);
+            }
+            break;
+          case 24:
+            {
+              unsigned char *rgb=pOut;
+              /* Write out top two pixels */
+		          rgb[0] = LIMIT(b+y00); rgb[1] = LIMIT(g+y00); rgb[2] = LIMIT(r+y00);
+		          rgb[3] = LIMIT(b+y01); rgb[4] = LIMIT(g+y01); rgb[5] = LIMIT(r+y01);
+
+		          /* Skip down to next line to write out bottom two pixels */
+		          rgb += addL;
+		          rgb[0] = LIMIT(b+y10); rgb[1] = LIMIT(g+y10); rgb[2] = LIMIT(r+y10);
+              rgb[3] = LIMIT(b+y11); rgb[4] = LIMIT(g+y11); rgb[5] = LIMIT(r+y11);
+            }
+            break;
+          case 32:
+            {
+              unsigned char *rgb=pOut;
+              /* Write out top two pixels */
+		          rgb[0] = LIMIT(b+y00); rgb[1] = LIMIT(g+y00); rgb[2] = LIMIT(r+y00);
+		          rgb[4] = LIMIT(b+y01); rgb[5] = LIMIT(g+y01); rgb[6] = LIMIT(r+y01);
+
+		          /* Skip down to next line to write out bottom two pixels */
+		          rgb += addL;
+		          rgb[0] = LIMIT(b+y10); rgb[1] = LIMIT(g+y10); rgb[2] = LIMIT(r+y10);
+              rgb[4] = LIMIT(b+y11); rgb[5] = LIMIT(g+y11); rgb[6] = LIMIT(r+y11);
+            }
+            break;
+          }
+        }
+	
+			  pY += 2;
+			  pOut += 2 * bytes;
+      }
+		  pY += yrb+yrb-width;
+		  pU += planes->u.rowBytes-width/2;
+		  pV += planes->v.rowBytes-width/2;
+		  pOut += addOut;
+	  }
+  } else if(type==NSV_MAKETYPE('R','G','3','2')) {
+    //FUCKO: do we need to support 8bits depth?
+    switch(m_depth) {
+    case 15: 
+      { // convert RGB32 -> RGB16 (555)
+        const char *a=buf;
+        char *b=(char *)dd.lpSurface;
+        int l=width*4,l2=dd.lPitch;
+        int ladj=l;
+        if (flip) { a+=l*(height-1); ladj=-ladj; }
+        for(int i=0;i<height;i++) {
+          short *dest=(short *)b;
+          int *src=(int *)a;
+          for(int j=0;j<width;j++) {
+            int c=*(src++);
+            int r=c>>16;
+            int g=(c>>8) & 0xff;
+            int b=(c) & 0xff;
+            *(dest++)=((r>>3)<<10)|((g>>3)<<5)|(b>>3);
+          }
+          a+=ladj; b+=l2;
+        }
+      }
+      break;
+    case 16:
+      { // convert RGB32 -> RGB16
+        //FUCKO: this assumes 565
+        const char *a=buf;
+        char *b=(char *)dd.lpSurface;
+        int l=width*4,l2=dd.lPitch;
+        int ladj=l;
+        if (flip) { a+=l*(height-1); ladj=-ladj; }
+        for(int i=0;i<height;i++) {
+          short *dest=(short *)b;
+          int *src=(int *)a;
+          for(int j=0;j<width;j++) {
+            //FUCKO: optimize here
+            int c=*(src++);
+            int r=c>>16;
+            int g=(c>>8) & 0xff;
+            int b=(c) & 0xff;
+            *(dest++)=((r>>3)<<11)|((g>>2)<<5)|(b>>3);
+          }
+          a+=ladj; b+=l2;
+        }
+      }
+      break;
+    case 24:
+      { // convert RGB32 -> RGB24
+        const char *a=buf;
+        char *b=(char *)dd.lpSurface;
+        int l=width*4,l2=dd.lPitch;
+        int ladj=l;
+        if (flip) { a+=l*(height-1); ladj=-ladj; }
+        for(int i=0;i<height;i++) {
+          char *dest=(char *)b;
+          int *src=(int *)a;
+          for(int j=0;j<width;j++) {
+            //FUCKO: optimize here
+            int c=*(src++);
+            int r=c>>16;
+            int g=(c>>8) & 0xff;
+            int b=(c) & 0xff;
+            *dest++=b;
+            *dest++=g;
+            *dest++=r;
+          }
+          a+=ladj; b+=l2;
+        }
+      }
+      break;
+    case 32:
+      { // straight RGB32 copy
+        const char *a=buf;
+        char *b=(char *)dd.lpSurface;
+        int l=width*4,l2=dd.lPitch;
+        int ladj=l;
+        if (flip) { a+=l*(height-1); ladj=-ladj; }
+        for(int i=0;i<height;i++) {
+          memcpy(b,a,l);
+          a+=ladj; b+=l2;
+        }
+      }
+      break;
+    }
+  } else if(type==NSV_MAKETYPE('Y','U','Y','2') || type==NSV_MAKETYPE('U','Y','V','Y')) {
+    const char *a=buf;
+    char *b=(char *)dd.lpSurface;
+    int l=width*2,l2=dd.lPitch;
+    if(flip) {
+      b+=(height-1)*l2;
+      l2=-l2;
+    }
+    switch(m_depth) {
+    case 15:
+      {
+        // yuy2->rgb16 (555) conversion
+        unsigned char *src=(unsigned char *)buf;
+        unsigned short *dst=(unsigned short *)dd.lpSurface;
+  	    int line, col;//, linewidth;
+        int y, yy;
+        int u, v;
+        int vr, ug, vg, ub;
+        unsigned char *py, *pu, *pv;
+
+        //linewidth = width - (width >> 1);
+        py = src;
+        pu = src + 1;
+        pv = src + 3;
+
+        int pitchadd=dd.lPitch/2-width;
+
+        for (line = 0; line < height; line++) {
+ 		      for (col = 0; col < width; col++) {
+            #undef LIMIT
+            #define LIMIT(x)  ( (x) > 0xffff ? 0xff : ( (x) <= 0xff ? 0 : ( (x) >> 8 ) ) )
+
+ 		        y = *py;
+	          yy = y << 8;
+	          u = *pu - 128;
+	          ug =   88 * u;
+	          ub =  454 * u;
+	          v = *pv - 128;
+	          vg =  183 * v;
+	          vr =  359 * v;
+                
+            unsigned char b=LIMIT(yy + ub     );
+            unsigned char g=LIMIT(yy - ug - vg);
+            unsigned char r=LIMIT(yy +      vr);
+            *(dst++)=((r>>3)<<10)|((g>>3)<<5)|(b>>3);
+    
+            py += 2;
+			      if ( (col & 1) == 1) {
+    			    pu += 4; // skip yvy every second y
+			        pv += 4; // skip yuy every second y
+			      }
+          } // ..for col 
+          dst+=pitchadd;
+        } /* ..for line */          
+      }
+      break;
+    case 16:
+      {
+        // yuy2->rgb16 conversion
+        //FUCKO: only supports 565
+        unsigned char *src=(unsigned char *)buf;
+        unsigned short *dst=(unsigned short *)dd.lpSurface;
+  	    int line, col;//, linewidth;
+        int y, yy;
+	      int u, v;
+        int vr, ug, vg, ub;
+        unsigned char *py, *pu, *pv;
+
+        //linewidth = width - (width >> 1);
+        py = src;
+        pu = src + 1;
+        pv = src + 3;
+
+        int pitchadd=dd.lPitch/2-width;
+
+        for (line = 0; line < height; line++) {
+ 		      for (col = 0; col < width; col++) {
+            #undef LIMIT
+            #define LIMIT(x)  ( (x) > 0xffff ? 0xff : ( (x) <= 0xff ? 0 : ( (x) >> 8 ) ) )
+
+		        y = *py;
+	          yy = y << 8;
+	          u = *pu - 128;
+	          ug =   88 * u;
+	          ub =  454 * u;
+	          v = *pv - 128;
+	          vg =  183 * v;
+	          vr =  359 * v;
+                
+            unsigned char b=LIMIT(yy + ub     );
+            unsigned char g=LIMIT(yy - ug - vg);
+            unsigned char r=LIMIT(yy +      vr);
+            *(dst++)=((r>>3)<<11)|((g>>2)<<5)|(b>>3);
+    
+            py += 2;
+			      if ( (col & 1) ) {
+    			    pu += 4; // skip yvy every second y
+			        pv += 4; // skip yuy every second y
+			      }
+		      } // ..for col 
+          dst+=pitchadd;
+	      } /* ..for line */          }
+      break;
+    case 24:
+      {
+        // yuy2->rgb24 conversion
+        unsigned char *src=(unsigned char *)buf;
+        unsigned char *dst=(unsigned char *)dd.lpSurface;
+  	    int line, col;//, linewidth;
+        int y, yy;
+        int u, v;
+        int vr, ug, vg, ub;
+        unsigned char *py, *pu, *pv;
+
+        //linewidth = width - (width >> 1);
+        py = src;
+        pu = src + 1;
+        pv = src + 3;
+
+        int pitchadd=dd.lPitch-(width*3);
+
+        for (line = 0; line < height; line++) {
+ 		      for (col = 0; col < width; col++) {
+            #undef LIMIT
+            #define LIMIT(x)  ( (x) > 0xffff ? 0xff : ( (x) <= 0xff ? 0 : ( (x) >> 8 ) ) )
+
+		        y = *py;
+	          yy = y << 8;
+	          u = *pu - 128;
+	          ug =   88 * u;
+	          ub =  454 * u;
+	          v = *pv - 128;
+	          vg =  183 * v;
+	          vr =  359 * v;
+                
+            *(dst++)=LIMIT(yy + ub     );
+            *(dst++)=LIMIT(yy - ug - vg);
+            *(dst++)=LIMIT(yy +      vr);
+    
+	          py += 2;
+            if ( (col & 1) == 1) {
+    			    pu += 4; // skip yvy every second y
+			        pv += 4; // skip yuy every second y
+			      }
+		      } // ..for col 
+          dst+=pitchadd;
+	      } /* ..for line */          }
+      break;
+    case 32:
+      {
+        // yuy2->rgb32 conversion
+        unsigned char *src=(unsigned char *)buf;
+        unsigned char *dst=(unsigned char *)dd.lpSurface;
+   	    int line, col;//, linewidth;
+        int y, yy;
+        int u, v;
+        int vr, ug, vg, ub;
+        unsigned char *py, *pu, *pv;
+
+        //linewidth = width - (width >> 1);
+        py = src;
+        pu = src + 1;
+        pv = src + 3;
+
+        int pitchadd=dd.lPitch-(width*4);
+
+        for (line = 0; line < height; line++) {
+ 		      for (col = 0; col < width; col++) {
+            #undef LIMIT
+            #define LIMIT(x)  ( (x) > 0xffff ? 0xff : ( (x) <= 0xff ? 0 : ( (x) >> 8 ) ) )
+
+ 		        y = *py;
+	          yy = y << 8;
+	          u = *pu - 128;
+	          ug =   88 * u;
+	          ub =  454 * u;
+	          v = *pv - 128;
+	          vg =  183 * v;
+	          vr =  359 * v;
+                
+		        *dst++ = LIMIT(yy + ub     ); // b
+	          *dst++ = LIMIT(yy - ug - vg); // g
+	          *dst++ = LIMIT(yy +      vr); // r
+            dst++;
+ 
+            py += 2;
+			      if ( (col & 1) == 1) {
+    			    pu += 4; // skip yvy every second y
+			        pv += 4; // skip yuy every second y
+			      }
+		      } // ..for col 
+          dst+=pitchadd;
+	      } /* ..for line */
+      }
+      break;
+    }
+  } else if(type==NSV_MAKETYPE('R','G','2','4')) {
+    //FUCKO: only ->RGB32 conversion supported
+    switch(m_depth) {
+    case 32:
+    {
+      const char *a=buf;
+      char *b=(char *)dd.lpSurface;
+      int l=width,l2=dd.lPitch;
+      int ladj=l*3;
+      if (flip) { a+=(l*3)*(height-1); ladj=-(ladj+l*3); }
+      l2-=l*4;
+      for(int i=0;i<height;i++) {
+        //memcpy(b,a,l);
+        for(int j=0;j<l;j++) {
+          b[0]=a[0];
+          b[1]=a[1];
+          b[2]=a[2];
+          b+=4; a+=3;
+        }
+        a+=ladj; b+=l2;
+      }
+    }
+    break;
+    }
+  } else if(type==NSV_MAKETYPE('R','G','B','8') && m_palette) {
+    unsigned char *d=(unsigned char *)dd.lpSurface;
+    int pitch=dd.lPitch;
+    unsigned char *src=(unsigned char *)buf;
+    int newwidth=(width+3)&0xfffc;
+    src+=newwidth*height-1;
+    for(int j=0;j<height;j++) {
+      switch(m_depth) {
+      case 15:
+      case 16:
+        {
+          unsigned short *dest=(unsigned short *)d;
+          for(int i=0;i<newwidth;i++) {
+            unsigned char c=src[-newwidth+1+i];
+            RGBQUAD *rgb=&m_palette[c];
+            switch(m_depth) {
+              case 15: *(dest++)=((rgb->rgbRed>>3)<<10)|((rgb->rgbGreen>>3)<<5)|(rgb->rgbBlue>>3); break;
+              case 16: *(dest++)=((rgb->rgbRed>>3)<<11)|((rgb->rgbGreen>>2)<<5)|(rgb->rgbBlue>>3); break;
+            }
+          }
+        }
+        break;
+      case 24:
+      case 32:
+        {
+          unsigned char *dest=d;
+          for(int i=0;i<newwidth;i++) {
+            unsigned char c=src[-newwidth+1+i];
+            RGBQUAD *rgb=&m_palette[c];
+            *dest++=rgb->rgbBlue;
+            *dest++=rgb->rgbGreen;
+            *dest++=rgb->rgbRed;
+            if(m_depth==32) dest++;
+          }
+        }
+        break;
+      }
+      d+=pitch;
+      src-=newwidth;
+    }
+  }
+
+  lpddsOverlay->Unlock(&dd);
+
+
+  RECT r;
+  HWND hwnd=m_parent->getHwnd();
+  if (!IsWindow(hwnd)) return;
+
+  if(GetParent(hwnd)) hwnd=GetParent(hwnd);
+
+  GetClientRect(hwnd,&r);
+  RECT fullr=r;
+  m_parent->adjustAspect(r);
+  if (r.left != lastresizerect.left || r.right != lastresizerect.right || r.top != lastresizerect.top || 
+        r.bottom != lastresizerect.bottom)
+  {
+    if (r.left != 0)
+    {
+      RECT tmp={0,0,r.left,fullr.bottom};
+      InvalidateRect(hwnd,&tmp,TRUE); 
+    }
+    
+    if (r.right != fullr.right) 
+    {
+      RECT tmp={r.right,0,fullr.right,fullr.bottom};
+      InvalidateRect(hwnd,&tmp,TRUE); 
+    }
+    if (r.top != 0) 
+    {
+      RECT tmp={r.left,0,r.right,r.top};
+      InvalidateRect(hwnd,&tmp,TRUE); 
+    }
+    if (r.bottom != fullr.bottom) 
+    {
+      RECT tmp={r.left,r.bottom,r.right,fullr.bottom};
+      InvalidateRect(hwnd,&tmp,TRUE); 
+    }
+
+    lastresizerect=r;
+  }
+
+  ClientToScreen(hwnd,(LPPOINT)&r);
+  ClientToScreen(hwnd,((LPPOINT)&r) + 1);
+
+  // transform coords from windows desktop coords (where 0,0==upper-left corner of box encompassing all monitors)
+  // to the coords for the monitor we're displaying on:
+  r.left-=m_mon_x;
+  r.right-=m_mon_x;
+  r.top-=m_mon_y;
+  r.bottom-=m_mon_y;
+
+  HDC hdc = NULL;
+  HDC inhdc = NULL;
+
+  RECT srcrect;
+  RECT *pSrcRect = NULL;
+
+  if (m_parent->osdShowing() && m_parent->osdReady())
+  {
+    // squish image upward to make room for the OSD.
+    int vert_margin = ((fullr.bottom-fullr.top) - (r.bottom-r.top)) / 2;
+    int pixels_to_clip = max(0, m_parent->getOSDbarHeight() - vert_margin);
+
+    // adjust source rectangle:
+    int src_y0 = (int)(height*pixels_to_clip/(float)(r.bottom-r.top) + 0.5f);
+    int src_y1 = height - src_y0;
+    SetRect(&srcrect, 0, SHOW_STREAM_TITLE_AT_TOP ? src_y0 : 0, width, src_y1);
+    pSrcRect = &srcrect;
+
+    // adjust destination rectangle:
+    r.bottom -= pixels_to_clip;
+#if (SHOW_STREAM_TITLE_AT_TOP)
+    r.top += pixels_to_clip;
+#endif
+  }
+
+  int needst=0;
+
+
+  SubsItem *mlst=m_lastsubtitle;
+  if (mlst)
+  { 
+    int curw=r.right-r.left, curh=r.bottom-r.top;
+    if (!lpddsSTTemp || sttmp_w != curw || sttmp_h != curh)
+    {
+      if (lpddsSTTemp) lpddsSTTemp->Release();
+      lpddsSTTemp=0;
+
+      HRESULT v=-1;
+      DDSURFACEDESC DDsd={sizeof(DDsd),};
+      DDSURFACEDESC   ddsd;
+      INIT_DIRECTDRAW_STRUCT(ddsd);
+      ddsd.dwFlags = DDSD_CAPS;
+      ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+      lpddsPrimary->GetSurfaceDesc(&ddsd);
+      DDsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT; //create the surface at screen depth
+	    DDsd.dwWidth=sttmp_w=curw;
+	    DDsd.dwHeight=sttmp_h=curh;
+	    DDsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
+	    if (m_parent->vid_ddraw) v=lpDD->CreateSurface(&DDsd, &lpddsSTTemp, NULL);
+      if (!m_parent->vid_ddraw || FAILED(v)) {
+        // fall back to system memory if video mem doesn't work
+        DDsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
+  	    v=lpDD->CreateSurface(&DDsd, &lpddsSTTemp, NULL);
+      }
+      m_sub_needremeasure=1;
+    }
+    if (lpddsSTTemp) needst=1;
+  }
+
+  if (needst)
+  {
+    HDC tmpdc=NULL;
+    if (!m_parent->vid_ddraw || lpddsSTTemp->Blt(NULL,lpddsOverlay,NULL,DDBLT_WAIT,0) != DD_OK) {
+      // as a last resort, BitBlt().
+      HDC tmpdc2;
+      if (lpddsOverlay->GetDC(&tmpdc2)==DD_OK) {
+        if (lpddsSTTemp->GetDC(&tmpdc)==DD_OK) {
+          BitBlt(tmpdc,0,0,sttmp_w,sttmp_h,tmpdc2,0,0,SRCCOPY);
+        }
+      }
+    }
+
+    if (tmpdc||lpddsSTTemp->GetDC(&tmpdc)==DD_OK)
+    {
+      int m_lastsubxp=mlst->xPos;
+      int m_lastsubyp=mlst->yPos;
+
+      RECT oldwinRect=winRect;
+      GetClientRect(hwnd,&winRect);
+      if(!subFont || ((winRect.bottom-winRect.top)!=(oldwinRect.bottom-oldwinRect.top)) || m_fontsize!=mlst->fontSize) {
+        if(subFont) DeleteObject(subFont);
+        m_fontsize=mlst->fontSize;
+        subFont=CreateFont(14+m_fontsize+18*(winRect.bottom-winRect.top)/768,0,0,0,FW_SEMIBOLD,FALSE,FALSE,FALSE,ANSI_CHARSET,OUT_OUTLINE_PRECIS,CLIP_DEFAULT_PRECIS,ANTIALIASED_QUALITY,DEFAULT_PITCH|FF_DONTCARE,"Arial");
+      }
+
+      HWND hwnd=m_parent->getHwnd();
+      HGDIOBJ oldobj=SelectObject(tmpdc,subFont);
+
+      int centerflags=0;
+      if (m_lastsubxp < 127) centerflags |= DT_LEFT;
+      else if (m_lastsubxp > 127) centerflags |= DT_RIGHT;
+      else centerflags |= DT_CENTER;
+
+      if (m_lastsubyp < 127) centerflags |= DT_TOP;
+      else if (m_lastsubyp > 127) centerflags |= DT_BOTTOM;
+
+      if (m_sub_needremeasure)
+      {
+        subRect=r;
+        subRect.bottom-=subRect.top;
+        subRect.right -=subRect.left;
+        subRect.top=subRect.left=0;
+
+        SIZE s;
+        GetTextExtentPoint32(tmpdc,mlst->text,strlen(mlst->text),&s);
+
+        // calcul for multiline text
+          const char *p=mlst->text;
+          int n=0;
+          while(*p!=0) if(*p++=='\n') n++;
+          if(n) s.cy*=(n+1);
+ 
+        if (m_lastsubxp > 127) // towards the right
+        {
+          subRect.right -= ((subRect.right-subRect.left) * (255-m_lastsubxp)) / 256;
+        }
+        else if (m_lastsubxp < 127)
+        {
+          subRect.left += ((subRect.right-subRect.left) * m_lastsubxp) / 256;
+        }
+
+        subRect.top += ((subRect.bottom-s.cy-subRect.top) * m_lastsubyp)/255;
+
+        subRect.bottom=subRect.top + s.cy;  
+      }
+  
+      SetBkMode(tmpdc,TRANSPARENT);
+  
+      // draw outline
+      SetTextColor(tmpdc,RGB(0,0,0));
+      int y=1;
+      int x=1;
+      RECT r2={subRect.left+x,subRect.top+y,subRect.right+x,subRect.bottom+y};
+      DrawText(tmpdc,mlst->text,-1,&r2,centerflags|DT_NOCLIP|DT_NOPREFIX);
+      // draw text
+      SetTextColor(tmpdc,RGB(mlst->colorRed,mlst->colorGreen,mlst->colorBlue));
+      DrawText(tmpdc,mlst->text,-1,&subRect,centerflags|DT_NOCLIP|DT_NOPREFIX);
+      SelectObject(tmpdc,oldobj);
+      lpddsSTTemp->ReleaseDC(tmpdc);
+    }
+    if (!m_parent->vid_ddraw || lpddsPrimary->Blt(&r,lpddsSTTemp,pSrcRect,DDBLT_WAIT,0) != DD_OK) {
+      // as a last resort, BitBlt().
+      if (lpddsSTTemp->GetDC(&inhdc)==DD_OK) {
+        if (lpddsPrimary->GetDC(&hdc)==DD_OK) {
+          int src_w = width;
+          int src_h = pSrcRect ? (pSrcRect->bottom - pSrcRect->top) : height;
+          if (r.right-r.left == src_w && r.bottom-r.top == src_h) 
+            BitBlt(hdc,r.left,r.top,r.right-r.left,r.bottom-r.top,inhdc,0,0,SRCCOPY);
+          else 
+            StretchBlt(hdc,r.left,r.top,r.right-r.left,r.bottom-r.top,inhdc,0,0,src_w,src_h,SRCCOPY);
+        }
+      }
+    }
+  }
+  else
+  {
+    if (!m_parent->vid_ddraw || lpddsPrimary->Blt(&r,lpddsOverlay,pSrcRect,DDBLT_WAIT,0) != DD_OK) {
+      // as a last resort, BitBlt().
+      if (lpddsOverlay->GetDC(&inhdc)==DD_OK) {
+        if (lpddsPrimary->GetDC(&hdc)==DD_OK) {
+          int src_w = width;
+          int src_h = pSrcRect ? (pSrcRect->bottom - pSrcRect->top) : height;
+          if (r.right-r.left == src_w && r.bottom-r.top == src_h) 
+            BitBlt(hdc,r.left,r.top,r.right-r.left,r.bottom-r.top,inhdc,0,0,SRCCOPY);
+          else 
+            StretchBlt(hdc,r.left,r.top,r.right-r.left,r.bottom-r.top,inhdc,0,0,src_w,src_h,SRCCOPY);
+        }
+      }
+    }
+  }
+
+#if 0 //faster style
+  if (m_parent->osdShowing())
+  {
+    if (hdc || lpddsPrimary->GetDC(&hdc)==DD_OK)
+      m_parent->drawOSD(hdc, &r);
+  }
+#endif
+
+  if (hdc) { lpddsPrimary->ReleaseDC(hdc); hdc = NULL; }
+  if (inhdc) { lpddsOverlay->ReleaseDC(inhdc); inhdc = NULL; }
+
+#if 1 // safer style
+  if (m_parent->osdShowing())
+  {
+    HWND h=m_parent->getHwnd();
+    hdc=GetDC(h);
+    m_parent->drawOSD(hdc, &r);
+    ReleaseDC(h,hdc);
+  }
+#endif
+}
+
+void DDrawVideoOutput::goFullScreen() {
+}
+
+void DDrawVideoOutput::removeFullScreen() {
+}
+
+void DDrawVideoOutput::timerCallback() {
+}
+
+int DDrawVideoOutput::showOSD() { 
+  return 1;
+}
+
+void DDrawVideoOutput::hideOSD() { 
+  // repaint the client area, to black, where there is no video
+  // (otherwise the OSD might be left painted there)
+
+  RECT r;
+  HWND hwnd=m_parent->getHwnd();
+  if(GetParent(hwnd)) hwnd=GetParent(hwnd);
+  GetClientRect(hwnd,&r);
+
+  HDC hdc = GetDC(hwnd);
+  if (hdc) {
+    HGDIOBJ oldobj1=SelectObject(hdc,CreateSolidBrush(RGB(0,0,0)));
+    HGDIOBJ oldobj2=SelectObject(hdc,CreatePen(PS_SOLID,0,RGB(0,0,0)));
+    int margin = ((r.bottom - r.top) - (lastresizerect.bottom - lastresizerect.top) + 1) / 2;
+    Rectangle(hdc,r.left,r.top,r.right,r.top + margin);
+    Rectangle(hdc,r.left,r.bottom - margin,r.right,r.bottom);
+    margin = ((r.right - r.left) - (lastresizerect.right - lastresizerect.left) + 1) / 2;
+    Rectangle(hdc,r.left,r.top,r.left + margin,r.bottom);
+    Rectangle(hdc,r.right - margin,r.top,r.right,r.bottom);
+    DeleteObject(SelectObject(hdc,oldobj2));
+    DeleteObject(SelectObject(hdc,oldobj1));
+    
+    ReleaseDC(hwnd, hdc);
+  }
+}
+
+void DDrawVideoOutput::resetSubtitle()
+{
+  m_lastsubtitle=0;
+}
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/vid_ddraw.h b/Src/nsv/nsvplay/vid_ddraw.h
new file mode 100644
index 00000000..0feea9f5
--- /dev/null
+++ b/Src/nsv/nsvplay/vid_ddraw.h
@@ -0,0 +1,63 @@
+#ifndef _VIDEO_DDRAW_H
+#define _VIDEO_DDRAW_H
+
+#include <ddraw.h>
+#include "video.h"
+
+class SubsItem;
+
+class DDrawVideoOutput : public VideoOutputChild {
+public:
+  DDrawVideoOutput();
+  virtual ~DDrawVideoOutput();
+
+  int create(VideoOutput *parent, int w, int h, unsigned int type, int flipit, double aspectratio); //return 1 if ok
+  int needChange() { return needchange; }
+
+  int onPaint(HWND hwnd, HDC hdc);
+  void displayFrame(const char *buf, int size, int time);
+
+  void goFullScreen();
+  void removeFullScreen();
+
+  void timerCallback();
+
+  void setPalette(RGBQUAD *pal) { m_palette=pal; }
+
+  int showOSD();
+  void hideOSD();
+
+  void drawSubtitle(SubsItem *item);
+  void resetSubtitle();
+
+private:
+  int width, height, flip;
+  int needchange;
+  unsigned int type;
+  VideoOutput *m_parent;
+  LPDIRECTDRAW		   lpDD;
+  LPDIRECTDRAWSURFACE lpddsOverlay, lpddsPrimary, lpddsSTTemp;
+  int sttmp_w, sttmp_h;
+  DDCAPS          capsDrv;
+  unsigned int    uDestSizeAlign, uSrcSizeAlign;
+  DWORD           dwUpdateFlags;
+  RECT rs,rd;
+  RECT lastresizerect;
+
+  bool initing;
+  int is_fullscreen;
+
+  LPDIRECTDRAWCLIPPER lpddsClipper;
+  DDPIXELFORMAT m_ddpf;
+  int m_depth;
+  RGBQUAD *m_palette;
+
+  HFONT subFont;
+  RECT subRect;
+  SubsItem *m_lastsubtitle;
+  int m_sub_needremeasure;
+  RECT winRect;
+  int m_fontsize;
+};
+
+#endif
diff --git a/Src/nsv/nsvplay/vid_overlay.cpp b/Src/nsv/nsvplay/vid_overlay.cpp
new file mode 100644
index 00000000..efe32661
--- /dev/null
+++ b/Src/nsv/nsvplay/vid_overlay.cpp
@@ -0,0 +1,654 @@
+#include "video.h"
+#include <multimon.h>
+#include "subtitles.h"
+
+#define INIT_DIRECTDRAW_STRUCT(x) (ZeroMemory(&x, sizeof(x)), x.dwSize=sizeof(x))
+#define OV_COL_R 16
+#define OV_COL_G 0
+#define OV_COL_B 16
+
+OverlayVideoOutput::OverlayVideoOutput() {
+  lpDD=NULL;
+  lpddsOverlay=NULL;
+  lpddsPrimary=NULL;
+  is_fullscreen=0;
+  yuy2_output=uyvy_output=0;
+  m_parent=NULL;
+  initing=false;
+  needchange=0;
+  memset(&m_oldrd,0,sizeof(m_oldrd));
+  memset(&winRect,0,sizeof(winRect));
+  subFont=NULL;
+  m_fontsize=0;
+  resetSubtitle();
+}
+
+OverlayVideoOutput::~OverlayVideoOutput() {
+  if(is_fullscreen) removeFullScreen();
+  LPDIRECTDRAWSURFACE o=lpddsOverlay;
+  lpddsOverlay=NULL;
+  if(o) o->Release();
+  if(lpddsPrimary) lpddsPrimary->Release();
+  if (lpDD) lpDD->Release();	// BU added NULL check in response to talkback
+  if(subFont) DeleteObject(subFont);
+}
+
+static DWORD DD_ColorMatch(LPDIRECTDRAWSURFACE pdds, COLORREF rgb)
+{
+  COLORREF rgbT;
+  HDC hdc;
+  DWORD dw = CLR_INVALID;
+  DDSURFACEDESC ddsd;
+  HRESULT hres;
+  
+  //
+  //  use GDI SetPixel to color match for us
+  //
+  if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
+  {
+	  rgbT = GetPixel(hdc, 0, 0);     // save current pixel value
+	  SetPixel(hdc, 0, 0, rgb);       // set our value
+	  pdds->ReleaseDC(hdc);
+  }
+  
+  //
+  // now lock the surface so we can read back the converted color
+  //
+  ddsd.dwSize = sizeof(ddsd);
+  while ((hres = pdds->Lock(NULL, &ddsd, 0, NULL)) == 
+	  DDERR_WASSTILLDRAWING)
+	  ;
+  
+  if (hres == DD_OK)
+  {
+	  dw  = *(DWORD *)ddsd.lpSurface;    // get DWORD
+    if(ddsd.ddpfPixelFormat.dwRGBBitCount<32)
+	    dw &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount) - 1;                        // mask it to bpp
+	  pdds->Unlock(NULL);
+  }
+  
+  //
+  //  now put the color that was there back.
+  //
+  if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
+  {
+	  SetPixel(hdc, 0, 0, rgbT);
+	  pdds->ReleaseDC(hdc);
+  }
+  
+  return dw;
+}
+
+int OverlayVideoOutput::create(VideoOutput *parent, int w, int h, unsigned int ptype, int flipit, double aspectratio) {
+  type=ptype;
+  width=w;
+  height=h;
+  flip=flipit;
+  m_parent=parent;
+
+  initing=true;
+  HWND hwnd=parent->getHwnd();
+
+  if (lpDD) lpDD->Release();
+  lpDD=NULL;
+
+  update_monitor_coords(parent);
+
+  if(!m_found_devguid) DirectDrawCreate(NULL,&lpDD,NULL);
+  else DirectDrawCreate(&m_devguid,&lpDD,NULL);
+
+  if(!lpDD) {
+    initing=false;
+    return 0;
+  }
+
+  lpDD->SetCooperativeLevel(hwnd,DDSCL_NOWINDOWCHANGES|DDSCL_NORMAL);
+
+  DDSURFACEDESC   ddsd;
+  INIT_DIRECTDRAW_STRUCT(ddsd);
+  ddsd.dwFlags = DDSD_CAPS;
+  ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+  HRESULT ddrval = lpDD->CreateSurface(&ddsd, &lpddsPrimary, NULL );
+
+  // init overlay
+  DDSURFACEDESC   ddsdOverlay;
+  INIT_DIRECTDRAW_STRUCT(ddsdOverlay);
+  ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
+  ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_PITCH;
+  ddsdOverlay.dwWidth=w;
+  ddsdOverlay.dwHeight=h;
+  ddsdOverlay.lPitch=w*4;
+  ddsdOverlay.dwBackBufferCount=0;
+  DDPIXELFORMAT pf[]=
+  {
+    {sizeof(DDPIXELFORMAT),DDPF_FOURCC,MAKEFOURCC('Y','U','Y','2'),0,0,0,0,0},
+    {sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('U','Y','V','Y'),0,0,0,0,0}, // UYVY
+    {sizeof(DDPIXELFORMAT),DDPF_FOURCC,MAKEFOURCC('Y','V','1','2'),0,0,0,0,0},
+  };
+  int tab[5];
+  if(type==NSV_MAKETYPE('Y','U','Y','2')) {
+    tab[0]=0; // default is YUY2
+    tab[1]=1;
+    tab[2]=-1;
+  } else if(type==NSV_MAKETYPE('U','Y','V','Y')) {
+      tab[0]=1; // make UYVY default
+      tab[1]=0;
+      tab[2]=-1;
+  } else if(type==NSV_MAKETYPE('Y','V','1','2')) {
+      /*tab[0]=2;
+      tab[1]=0;
+      tab[2]=1;
+      tab[3]=-1;*/
+    //CT> Make YUY2 default too, cause YV12 is borked on some ATI cards/drivers :(
+    tab[0]=0;
+    tab[1]=1;
+    tab[2]=-1;
+  } else {
+      tab[0]=-1; // default is RGB
+  }
+
+  int x=4096;
+  HRESULT v=-1;
+  for (x = 0; x < sizeof(tab)/sizeof(tab[0]) && tab[x]>=0; x ++) {
+    ddsdOverlay.ddpfPixelFormat=pf[tab[x]];
+    v=lpDD->CreateSurface(&ddsdOverlay, &lpddsOverlay, NULL);
+    if (!FAILED(v)) break;
+  }
+  if(FAILED(v)||x>=sizeof(tab)/sizeof(tab[0])||tab[x]<0) {
+    initing=false;
+    return 0;
+  }
+
+  yuy2_output = (tab[x] == 0);
+  uyvy_output = (tab[x] == 1);
+
+  INIT_DIRECTDRAW_STRUCT(capsDrv);
+  ddrval = lpDD->GetCaps(&capsDrv, NULL);
+
+  uDestSizeAlign = capsDrv.dwAlignSizeDest;
+  uSrcSizeAlign =  capsDrv.dwAlignSizeSrc;
+
+  dwUpdateFlags = DDOVER_SHOW | DDOVER_KEYDESTOVERRIDE;
+
+  DEVMODE d;
+  d.dmSize=sizeof(d);
+  d.dmDriverExtra=0;
+  EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &d);
+
+  int rv=OV_COL_R, gv=OV_COL_G, bv=OV_COL_B;
+
+  INIT_DIRECTDRAW_STRUCT(ovfx);
+  ovfx.dwDDFX=0;
+  switch(d.dmBitsPerPel) {
+    case 16:
+      ovfx.dckDestColorkey.dwColorSpaceLowValue=((rv>>3) << 11) | ((gv>>2) << 5) | (bv>>3);
+      break;
+    case 15:
+      ovfx.dckDestColorkey.dwColorSpaceLowValue=((rv>>3) << 10) | ((gv>>3) << 5) | (bv>>3);
+      break;
+    case 24: case 32:
+      ovfx.dckDestColorkey.dwColorSpaceLowValue=(rv << 16) | (gv << 8) | bv;
+      break;
+  }
+
+  //try to get the correct bit depth thru directdraw (for fucked up 16 bits displays for ie.)
+  {
+    DDSURFACEDESC DDsd={sizeof(DDsd),};
+    lpddsPrimary->GetSurfaceDesc(&ddsd);
+    DDsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT; //create the surface at screen depth
+    DDsd.dwWidth=8;
+    DDsd.dwHeight=8;
+    DDsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
+    LPDIRECTDRAWSURFACE tempsurf;
+    if(lpDD->CreateSurface(&DDsd, &tempsurf, NULL)==DD_OK)
+    {
+      int res=DD_ColorMatch(tempsurf, RGB(rv,gv,bv));
+      if(res!=CLR_INVALID) ovfx.dckDestColorkey.dwColorSpaceLowValue=res;
+      tempsurf->Release();
+    }
+  }
+
+  ovfx.dckDestColorkey.dwColorSpaceHighValue=ovfx.dckDestColorkey.dwColorSpaceLowValue;
+
+  getRects(&rs,&rd);
+  if(FAILED(lpddsOverlay->UpdateOverlay(&rs, lpddsPrimary, &rd, dwUpdateFlags, &ovfx))) {
+    initing=false;
+    return 0;
+  }
+  initing=false;
+
+  DDSURFACEDESC dd={sizeof(dd),};
+  if (lpddsOverlay->Lock(NULL,&dd,DDLOCK_WAIT,NULL) != DD_OK) return 0;
+  unsigned char *o=(unsigned char*)dd.lpSurface;
+  if (uyvy_output||yuy2_output) 
+  {
+    int x=dd.lPitch*height/2;
+    while (x--)
+    {
+      if (uyvy_output)
+      {
+        *o++=128;
+        *o++=0;
+      }
+      else
+      {
+        *o++=0;
+        *o++=-128;
+      }
+    }
+  }
+  else
+  {
+    memset(o,0,dd.lPitch*height); o+=dd.lPitch*height;
+    memset(o,128,dd.lPitch*height/2);
+  }
+  lpddsOverlay->Unlock(&dd);
+
+  InvalidateRect(hwnd,NULL,TRUE);
+  return 1;
+}
+
+void OverlayVideoOutput::getRects(RECT *drs, RECT *drd) {
+  HWND hwnd=m_parent->getHwnd();
+  if(GetParent(hwnd)) hwnd=GetParent(hwnd);
+
+  RECT rd,rs;
+  GetClientRect(hwnd,&rd);
+  ClientToScreen(hwnd,(LPPOINT)&rd);
+  ClientToScreen(hwnd,((LPPOINT)&rd) + 1);
+
+  m_parent->adjustAspect(rd);
+  rd.left-=m_mon_x;
+  rd.right-=m_mon_x;
+  rd.top-=m_mon_y;
+  rd.bottom-=m_mon_y;
+
+  memset(&rs,0,sizeof(rs));
+  rs.right=width;
+  rs.bottom=height;
+
+  //resize overlay for off-screen
+  RECT rfull;
+  //m_parent->getViewport(&rfull,NULL,1); //FUCKO: assume monitor 0
+  m_parent->getViewport(&rfull,hwnd,1);   //FUCKO: okay to use this hwnd? (fixes multimon! -RG)
+  if(rd.right>rfull.right) {
+    int diff=rd.right-rfull.right;
+    float sc=(float)(width)/(float)(rd.right-rd.left);
+    rd.right=rfull.right;
+    rs.right=width-(int)(diff*sc);
+  }
+  if(rd.left<rfull.left) {
+    int diff=rfull.left-rd.left;
+    float sc=(float)(width)/(float)(rd.right-rd.left);
+    rd.left=rfull.left;
+    rs.left=(int)(diff*sc);
+  }
+  if(rd.bottom>rfull.bottom) {
+    int diff=rd.bottom-rfull.bottom;
+    float sc=(float)(height)/(float)(rd.bottom-rd.top);
+    rd.bottom=rfull.bottom;
+    rs.bottom=height-(int)(diff*sc);
+  }
+  if(rd.top<rfull.top) {
+    int diff=rfull.top-rd.top;
+    float sc=(float)(height)/(float)(rd.bottom-rd.top);
+    rd.top=rfull.top;
+    rs.top=(int)(diff*sc);
+  }
+
+  if (capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC && uDestSizeAlign) {
+    rs.left = (int)((rs.left+uDestSizeAlign-1)/uDestSizeAlign)*uDestSizeAlign;
+    rs.right = (int)((rs.right+uDestSizeAlign-1)/uDestSizeAlign)*uDestSizeAlign;
+  }
+  if (capsDrv.dwCaps & DDCAPS_ALIGNSIZEDEST && uDestSizeAlign) {
+    rd.left = (int)((rd.left+uDestSizeAlign-1)/uDestSizeAlign)*uDestSizeAlign;
+    rd.right = (int)((rd.right+uDestSizeAlign-1)/uDestSizeAlign)*uDestSizeAlign;
+  }
+
+  *drd=rd;
+  *drs=rs;
+}
+
+void OverlayVideoOutput::timerCallback() {
+  if(!m_parent) return;
+
+  RECT rd,rs;
+  getRects(&rs,&rd);
+
+  if(memcmp(&m_oldrd,&rd,sizeof(RECT))) {
+    m_oldrd=rd;
+    if(!initing && lpddsOverlay) 
+      if(FAILED(lpddsOverlay->UpdateOverlay(&rs, lpddsPrimary, &rd, dwUpdateFlags, &ovfx))) {
+        needchange=1;
+      }
+  }
+}
+
+int OverlayVideoOutput::onPaint(HWND hwnd, HDC hdc) {
+  if(!m_parent) return 0;
+
+  PAINTSTRUCT p;
+  BeginPaint(hwnd,&p);
+
+  RECT r;
+  GetClientRect(hwnd,&r);
+  LOGBRUSH lb={BS_SOLID,RGB(OV_COL_R,OV_COL_G,OV_COL_B),};
+  HBRUSH br=CreateBrushIndirect(&lb);
+  FillRect(p.hdc,&r,br);
+  DeleteObject(br);
+
+  if (curSubtitle)
+  {
+    int m_lastsubxp=curSubtitle->xPos;
+    int m_lastsubyp=curSubtitle->yPos;
+
+    HDC out=p.hdc;
+  
+    HGDIOBJ oldobj=SelectObject(out,subFont);
+  
+    SetBkMode(out,TRANSPARENT);
+    int centerflags=0;
+    if (m_lastsubxp < 127) centerflags |= DT_LEFT;
+    else if (m_lastsubxp > 127) centerflags |= DT_RIGHT;
+    else centerflags |= DT_CENTER;
+
+    if (m_lastsubyp < 127) centerflags |= DT_TOP;
+    else if (m_lastsubyp > 127) centerflags |= DT_BOTTOM;
+  
+    // draw outline
+    SetTextColor(out,RGB(0,0,0));
+    for (int y = -1; y < 2; y++)
+      for (int x = -1; x < 2; x++)
+      {
+        if(!y && !x) continue;
+        RECT r2={subRect.left+x,subRect.top+y,subRect.right+x,subRect.bottom+y};
+        DrawText(out,curSubtitle->text,-1,&r2,centerflags|DT_NOCLIP|DT_NOPREFIX);
+      }
+    // draw text
+    SetTextColor(out,RGB(curSubtitle->colorRed,curSubtitle->colorGreen,curSubtitle->colorBlue));
+    DrawText(out,curSubtitle->text,-1,&subRect,centerflags|DT_NOCLIP|DT_NOPREFIX);
+    SelectObject(out,oldobj);
+  }
+
+  EndPaint(hwnd,&p);
+
+  return 1;
+}
+
+void OverlayVideoOutput::displayFrame(const char *buf, int size, int time) {
+  if(!m_parent) return;
+  
+  DDSURFACEDESC dd={sizeof(dd),};
+  if (m_parent->vid_vsync) lpDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN,0);
+  HRESULT result;
+  if ((result=lpddsOverlay->Lock(NULL,&dd,DDLOCK_WAIT,NULL)) != DD_OK) {
+    //CT>FUCKO:reenable me (ctrl+alt+del on win2k)
+    //if(result==DDERR_SURFACELOST) width=-1; //will try to recreate the surface in the next processData() call
+    return;
+  }
+  if(type==NSV_MAKETYPE('Y','V','1','2')) {
+    const YV12_PLANES *planes=(YV12_PLANES *)buf;
+    if (uyvy_output||yuy2_output) { // YV12planar->UYVY or YUY2
+      unsigned char *o=(unsigned char*)dd.lpSurface;
+      const unsigned char *yi=planes->y.baseAddr;
+      const unsigned char *ui=planes->u.baseAddr;
+      const unsigned char *vi=planes->v.baseAddr;
+      int y=height;
+      if (flip) o+=dd.lPitch*(height-1);
+      while (y>0) {
+        int x=width;
+        unsigned char *oo=o;
+      
+        if (uyvy_output) while (x>0) {
+          o[0]=*ui++; o[1]=*yi++; o[2]=*vi++; o[3]=*yi++;
+          o+=4; x-=2;
+        }
+        else while (x>0) {
+          o[0]=*yi++; o[1]=*ui++; o[2]=*yi++; o[3]=*vi++;
+          o+=4; x-=2;
+        }
+        ui-=width/2;
+        vi-=width/2;
+        yi+=planes->y.rowBytes-width;
+        x=width;
+        if (flip) o=oo-dd.lPitch;
+        else o+=dd.lPitch-width*2;
+        oo=o;
+        if (uyvy_output) while (x>0) {
+          o[0]=*ui++; o[1]=*yi++; o[2]=*vi++; o[3]=*yi++;
+          o+=4; x-=2;
+        } else while (x>0) {
+          o[0]=*yi++; o[1]=*ui++; o[2]=*yi++; o[3]=*vi++;
+          o+=4; x-=2;
+        }
+        if (flip) o=oo-dd.lPitch;
+        else o+=dd.lPitch-width*2;
+        ui+=planes->u.rowBytes-(width/2);
+        vi+=planes->v.rowBytes-(width/2);
+        yi+=planes->y.rowBytes-width;
+        y-=2;
+      }
+    } else { // woo native YV12 copy
+      int f=!!flip;
+      char *o=(char*)dd.lpSurface+(f*height*dd.lPitch);
+      const char *i=(const char*)planes->y.baseAddr;
+      int d_o=dd.lPitch;
+      if (f) d_o=-d_o;
+      else o-=d_o;
+  
+      int h2=height;
+      while (h2--) {
+        o+=d_o; memcpy(o,i,width); i+=planes->y.rowBytes;
+      }
+
+      d_o/=2;
+
+      int w2=width/2;
+      h2=height/2;
+      i=(const char*)planes->v.baseAddr;
+      o=(char*)dd.lpSurface+(height*dd.lPitch*(f+4))/4;
+
+      if (!f) o-=d_o;
+      while (h2--) {
+        o+=d_o; memcpy(o,i,w2); i+=planes->v.rowBytes;
+      }
+      o=(char*)dd.lpSurface+(height*dd.lPitch*(f+5))/4;
+      i=(const char*)planes->u.baseAddr;
+      h2=height/2;
+
+      if (!f) o-=d_o;
+      while (h2--) {
+        o+=d_o; memcpy(o,i,w2);i+=planes->u.rowBytes;
+      }
+    }
+  } else if(type==NSV_MAKETYPE('Y','U','Y','2') || type==NSV_MAKETYPE('U','Y','V','Y')) {
+    const char *a=buf;
+    char *b=(char *)dd.lpSurface;
+    int l=width*2,l2=dd.lPitch;
+    if(flip) {
+      b+=(height-1)*l2;
+      l2=-l2;
+    }
+    int is_uyvy=type==NSV_MAKETYPE('U','Y','V','Y');
+    if (uyvy_output && !is_uyvy || (yuy2_output && is_uyvy)) // convert to uyvy
+    {
+      for(int i=0;i<height;i++) {
+        int x=width/2;
+        while (x-->0) {
+          b[0]=a[1];
+          b[1]=a[0];
+          b[2]=a[3];
+          b[3]=a[2];
+          a+=4;
+          b+=4;          
+        }
+        memcpy(b,a,l);
+        b+=l2;
+        a+=l;
+      }
+    } else {
+      //wee straight YUY2 copy
+      for(int i=0;i<height;i++) {
+        memcpy(b,a,l);
+        b+=l2;
+        a+=l;
+      }
+    }
+  }
+
+  lpddsOverlay->Unlock(&dd);
+
+  if (m_parent->osdShowing())
+  {
+    RECT rs, rd;
+    getRects(&rs,&rd);
+
+    HDC hdc;
+#if 1 // set both these 1s to 0s to put it back on ryan's mode
+    HWND h=m_parent->getHwnd();
+    hdc=GetDC(h);
+#else
+    if (lpddsPrimary->GetDC(&hdc)==DD_OK)
+    {
+#endif
+      m_parent->drawOSD(hdc, &rd);
+#if 1
+      ReleaseDC(h,hdc);
+#else
+      lpddsPrimary->ReleaseDC(hdc);
+    }
+#endif
+  }
+}
+
+void OverlayVideoOutput::goFullScreen() {
+/*  fullscreen_controls = new GuiObjectWnd;
+  fullscreen_controls->setContent("video.fullscreen_controls");
+  fullscreen_controls->init(m_parent);
+
+  RECT r;
+  Std::getViewport(&r,m_parent->gethWnd(),1);
+
+  RECT nr = r;
+  nr.top = (int)(r.bottom - (r.bottom - r.top) * 0.15);
+  nr.bottom = (int)(r.bottom - (r.bottom - r.top) * 0.05);
+  fullscreen_controls->resizeToRect(&nr);
+  */
+  is_fullscreen=1;
+}
+
+void OverlayVideoOutput::removeFullScreen() {
+/*  delete fullscreen_controls;
+  fullscreen_controls = NULL;*/
+  is_fullscreen=0;
+}
+
+int OverlayVideoOutput::showOSD() {
+//  if (fullscreen_controls != NULL) fullscreen_controls->setVisible(TRUE);
+
+  // enabling the following code will cause the top & bottom OSD bars 
+  // to squish the image (instead of crop it):
+  /*if(lpddsOverlay) {
+    RECT rd,rs;
+    getRects(&rs,&rd);
+    
+    HWND hwnd=m_parent->getHwnd();
+    if(GetParent(hwnd)) hwnd=GetParent(hwnd);
+    
+    RECT temp;
+    GetClientRect(hwnd,&temp);
+    int bottom_margin = ((temp.bottom-temp.top) - (rd.bottom-rd.top)) / 2;
+    int pixels_to_clip = max(0, m_parent->getOSDbarHeight() - bottom_margin);
+    rd.bottom -= pixels_to_clip;
+
+    lpddsOverlay->UpdateOverlay(&rs, lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
+  }*/
+
+
+  return 1;
+}
+
+void OverlayVideoOutput::hideOSD() { 
+  //if (fullscreen_controls != NULL) fullscreen_controls->setVisible(FALSE);
+
+  // 1) repaint the OSD area with the overlay color here
+  HWND hwnd = m_parent->getHwnd();
+  if(GetParent(hwnd)) hwnd=GetParent(hwnd);
+
+  HDC hdc = GetDC(hwnd);
+  if (hdc) {
+    RECT r;
+    GetClientRect(hwnd,&r);
+    LOGBRUSH lb={BS_SOLID,RGB(OV_COL_R,OV_COL_G,OV_COL_B),};
+    HBRUSH br=CreateBrushIndirect(&lb);
+    FillRect(hdc,&r,br);
+    DeleteObject(br);
+
+    ReleaseDC(hwnd, hdc);
+  }
+
+  // 2) readjust the overlay destination rectangle
+  /*if(lpddsOverlay) {
+    RECT rd,rs;
+    getRects(&rs,&rd);
+    lpddsOverlay->UpdateOverlay(&rs, lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
+  }*/
+
+}
+
+void OverlayVideoOutput::drawSubtitle(SubsItem *item) {
+  curSubtitle=item;
+
+  HWND hwnd=m_parent->getHwnd();
+
+  RECT oldrect=subRect;
+  GetClientRect(hwnd,&subRect);
+ 
+  if(item) {
+
+    RECT oldwinRect=winRect;
+    GetClientRect(hwnd,&winRect);
+    if(!subFont || ((winRect.bottom-winRect.top)!=(oldwinRect.bottom-oldwinRect.top)) || m_fontsize!=item->fontSize) {
+      if(subFont) DeleteObject(subFont);
+      m_fontsize=item->fontSize;
+      subFont=CreateFont(14+item->fontSize+18*(winRect.bottom-winRect.top)/768,0,0,0,FW_SEMIBOLD,FALSE,FALSE,FALSE,ANSI_CHARSET,OUT_OUTLINE_PRECIS,CLIP_DEFAULT_PRECIS,ANTIALIASED_QUALITY,DEFAULT_PITCH|FF_DONTCARE,"Arial");
+    }
+
+    HDC out=GetDC(hwnd);
+    SelectObject(out,subFont);
+    SIZE s;
+    GetTextExtentPoint32(out,item->text,strlen(item->text),&s);
+    {
+      // calcul for multiline text
+      const char *p=item->text;
+      int n=0;
+      while(*p!=0) if(*p++=='\n') n++;
+      if(n) s.cy*=(n+1);
+    }
+
+    if (item->xPos > 127) // towards the right
+    {
+      subRect.right -= ((subRect.right-subRect.left) * (255-item->xPos)) / 256;
+    }
+    else if (item->xPos < 127)
+    {
+      subRect.left += ((subRect.right-subRect.left) * item->xPos) / 256;
+    }
+
+    subRect.top += ((subRect.bottom-s.cy-subRect.top) * item->yPos)/255;
+
+    subRect.bottom=subRect.top + s.cy;  
+
+    ReleaseDC(hwnd,out);
+  }
+
+  //just redraw the correct portion
+  InvalidateRect(hwnd,&oldrect,TRUE); 
+  InvalidateRect(hwnd,&subRect,TRUE); 
+}
+
+void OverlayVideoOutput::resetSubtitle()
+{
+  curSubtitle=NULL;
+  subRect.top=65536;
+}
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/vid_overlay.h b/Src/nsv/nsvplay/vid_overlay.h
new file mode 100644
index 00000000..f4772e69
--- /dev/null
+++ b/Src/nsv/nsvplay/vid_overlay.h
@@ -0,0 +1,58 @@
+#ifndef _VIDEO_OVERLAY_H
+#define _VIDEO_OVERLAY_H
+
+#include <ddraw.h>
+#include <multimon.h>
+#include "video.h"
+
+class SubsItem;
+
+class OverlayVideoOutput : public VideoOutputChild {
+public:
+  OverlayVideoOutput();
+  virtual ~OverlayVideoOutput();
+
+  int create(VideoOutput *parent, int w, int h, unsigned int type, int flipit, double aspectratio); //return 1 if ok
+  int needChange() { return needchange; }
+
+  int onPaint(HWND hwnd, HDC hdc);
+  void displayFrame(const char *buf, int size, int time);
+
+  void goFullScreen();
+  void removeFullScreen();
+
+  void timerCallback();
+
+  int showOSD();
+  void hideOSD();
+
+  void drawSubtitle(SubsItem *item);
+  virtual void resetSubtitle();
+
+private:
+  int width, height, flip;
+  int needchange;
+  unsigned int type;
+  VideoOutput *m_parent;
+  LPDIRECTDRAW		   lpDD;
+  LPDIRECTDRAWSURFACE lpddsOverlay, lpddsPrimary;
+  DDCAPS          capsDrv;
+  unsigned int    uDestSizeAlign, uSrcSizeAlign;
+  DWORD           dwUpdateFlags;
+  DDOVERLAYFX     ovfx;
+  RECT rs,rd;
+  RECT m_oldrd;
+  RECT winRect;
+
+  bool initing;
+  int is_fullscreen, yuy2_output, uyvy_output;
+  
+  void getRects(RECT *drs, RECT *drd);
+
+  HFONT subFont;
+  RECT subRect;
+  SubsItem *curSubtitle;
+  int m_fontsize;
+};
+
+#endif
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/video.cpp b/Src/nsv/nsvplay/video.cpp
new file mode 100644
index 00000000..8a6532c7
--- /dev/null
+++ b/Src/nsv/nsvplay/video.cpp
@@ -0,0 +1,964 @@
+#include <windows.h>
+#include <ddraw.h>
+#include "main.h"
+#include "video.h"
+#include "subtitles.h"
+
+#include "resource.h"
+
+#undef GetSystemMetrics
+
+#define OSD_ENABLED 1
+
+#define INIT_DIRECTDRAW_STRUCT(x) (ZeroMemory(&x, sizeof(x)), x.dwSize=sizeof(x))
+#define OV_COL_R 16
+#define OV_COL_G 0
+#define OV_COL_B 16
+#define OSD_TEXT_SIZE 28
+#define OSD_TEXT_R 192
+#define OSD_TEXT_G 192
+#define OSD_TEXT_B 192
+#define OSD_TEXT_R_HILITE 255
+#define OSD_TEXT_G_HILITE 255 
+#define OSD_TEXT_B_HILITE 255
+#define OSD_VOL_COL_R 0
+#define OSD_VOL_COL_G 0
+#define OSD_VOL_COL_B 192
+#define OSD_VOL_BKCOL_R 0
+#define OSD_VOL_BKCOL_G 0
+#define OSD_VOL_BKCOL_B 64
+
+#define TIMER_OSD_ID 1234
+
+#define CTRLTYPE_SYMBOL   0
+#define CTRLTYPE_TEXT     1
+#define CTRLTYPE_PROGRESS 2
+#define CTRLTYPE_SPACER   3
+
+#define CTRL_PROGRESSTEXT 0
+#define CTRL_PROGRESS 1
+#define CTRL_PROGRESSSPACER 2
+#define CTRL_REW      3
+#define CTRL_PLAY     4
+#define CTRL_PAUSE    5
+#define CTRL_STOP     6
+#define CTRL_FFWD     7
+#define CTRL_VOLSPACER 8
+#define CTRL_VOLTEXT  9
+#define CTRL_VOL      10
+
+int g_ctrl_type[NUM_WIDGETS] = {
+  CTRLTYPE_TEXT,
+  CTRLTYPE_PROGRESS,
+  CTRLTYPE_SPACER,
+  CTRLTYPE_SYMBOL,
+  CTRLTYPE_SYMBOL,
+  CTRLTYPE_SYMBOL,
+  CTRLTYPE_SYMBOL,
+  CTRLTYPE_SYMBOL,
+  CTRLTYPE_SPACER,
+  CTRLTYPE_TEXT,
+  CTRLTYPE_PROGRESS
+};
+
+const char *g_ctrl_text[NUM_WIDGETS] = {
+  "Progress ", 
+  "",
+  "",
+  "7", // rew
+  "4", // play
+  ";", // pause
+  "<", // stop
+  "8", // ffwd
+  "",
+  "Volume ",
+  ""
+};
+
+int g_ctrl_force_width[NUM_WIDGETS] = {
+  0,  
+  96, // progress bar width
+  32, // spacer width
+  0,  // rew
+  0,  // play
+  0,  // pause
+  0,  // stop
+  0,  // ffwd
+  32, // spacer width
+  0, 
+  64  // volume bar width
+};
+
+extern HINSTANCE g_hInstance;
+extern int g_bitmap_id;
+
+static BOOL WINAPI DDEnumCallbackEx(GUID FAR *lpGUID, LPSTR     lpDriverDescription, LPSTR     lpDriverName, LPVOID    lpContext, HMONITOR  hm) {
+  VideoOutputChild *ovo=(VideoOutputChild *)lpContext;
+  if(ovo->m_found_devguid) return 1;
+  if(hm==ovo->m_monitor_to_find) {
+    ovo->m_devguid=*lpGUID;
+    ovo->m_found_devguid=1;
+  }
+  return 1;
+}
+
+void VideoOutputChild::update_monitor_coords(VideoOutput *parent)
+{
+  //find the correct monitor if multiple monitor support is present
+  HWND hwnd=parent->getHwnd();
+  m_found_devguid=0;
+  m_mon_x=0;
+  m_mon_y=0;
+
+	HINSTANCE h=LoadLibrary("user32.dll");
+	if (h) {
+		HMONITOR (WINAPI *Mfp)(POINT pt, DWORD dwFlags) = (HMONITOR (WINAPI *)(POINT,DWORD)) GetProcAddress(h,"MonitorFromPoint");
+    HMONITOR (WINAPI *Mfr)(LPCRECT lpcr, DWORD dwFlags) = (HMONITOR (WINAPI *)(LPCRECT, DWORD)) GetProcAddress(h, "MonitorFromRect");
+    HMONITOR (WINAPI *Mfw)(HWND wnd, DWORD dwFlags)=(HMONITOR (WINAPI *)(HWND, DWORD)) GetProcAddress(h, "MonitorFromWindow");
+    BOOL (WINAPI *Gmi)(HMONITOR mon, LPMONITORINFO lpmi) = (BOOL (WINAPI *)(HMONITOR,LPMONITORINFO)) GetProcAddress(h,"GetMonitorInfoA");    
+		if (Mfp && Mfr && Mfw && Gmi) {
+      RECT r;
+      GetWindowRect(hwnd,&r);
+      HMONITOR hm=Mfr(&r,NULL);
+      if(hm) {
+        HINSTANCE hdd = LoadLibrary("ddraw.dll");
+        if(hdd) {
+          typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXA)(GUID FAR *, LPSTR, LPSTR, LPVOID, HMONITOR);
+          typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEX)( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);
+          LPDIRECTDRAWENUMERATEEX lpDDEnumEx;
+          lpDDEnumEx = (LPDIRECTDRAWENUMERATEEX) GetProcAddress(hdd,"DirectDrawEnumerateExA");
+          if (lpDDEnumEx) {
+            m_monitor_to_find=hm;
+            lpDDEnumEx(&DDEnumCallbackEx, this, DDENUM_ATTACHEDSECONDARYDEVICES|DDENUM_NONDISPLAYDEVICES);
+            if(m_found_devguid) {
+              MONITORINFOEX mi;
+              memset(&mi,0,sizeof(mi));
+              mi.cbSize=sizeof(mi);
+              if (Gmi(hm,&mi)) {
+                m_mon_x=mi.rcMonitor.left;
+                m_mon_y=mi.rcMonitor.top;
+              }
+            }
+          }
+          FreeLibrary(hdd);
+        }
+      }
+    }
+    FreeLibrary(h);
+  }
+}
+
+int VideoOutput::get_latency()
+{
+  return vid_vsync?15:0;
+}
+
+#undef GetSystemMetrics
+int VideoOutput::class_refcnt=0;
+
+void VideoOutput::adjustAspect(RECT &rd)
+{
+  if (vid_aspectadj)
+  {
+    int outh=rd.bottom-rd.top;
+    int outw=rd.right-rd.left;
+
+    int newh=(int)((aspect*height*outw)/(double)width);
+    int neww=(int)((width*outh)/(height*aspect));
+
+    if (outh > newh) // black bars on top and bottom
+    {
+      int d=outh - newh;
+      rd.top+=d/2;
+      rd.bottom-=d-d/2;
+    }
+    else if (outw > neww) // black bars on left and right
+    {
+      int d=outw - neww;
+      rd.left+=d/2;
+      rd.right-=d-d/2;
+    }
+  }
+}
+
+LRESULT CALLBACK VideoOutput::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+  if (uMsg == WM_CREATE)
+  {
+    SetWindowLong(hwnd,GWL_USERDATA,(long)((CREATESTRUCT *)lParam)->lpCreateParams);
+    ShowWindow(hwnd,SW_SHOW);
+    if (GetParent(hwnd))
+    {
+      RECT r;
+      GetClientRect(GetParent(hwnd),&r);
+      SetWindowPos(hwnd,NULL,0,0,
+        r.right,
+        r.bottom,
+        SWP_NOACTIVATE|SWP_NOZORDER);
+    }
+    return 0;
+  }
+
+  VideoOutput *_This=(VideoOutput*)GetWindowLong(hwnd,GWL_USERDATA);
+  if (_This) return _This->WindowProc(hwnd,uMsg,wParam,lParam);
+  else return DefWindowProc(hwnd,uMsg,wParam,lParam);
+}
+
+void VideoOutput::notifyBufferState(int bufferstate) /* 0-255*/
+{
+  m_bufferstate=bufferstate;
+#ifdef ACTIVEX_CONTROL
+  PostMessage( video_hwnd, STATUS_MSG, STATUS_PREBUFFER, bufferstate );
+#endif
+  if (!m_video_output) {
+    if(GetTickCount()-m_lastbufinvalid>500) {
+      InvalidateRect(video_hwnd,NULL,FALSE);
+      m_lastbufinvalid=GetTickCount();
+    }
+  }
+}
+
+LRESULT VideoOutput::WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+  switch (uMsg)
+  {
+    case WM_TIMER:
+    case WM_WINDOWPOSCHANGING:
+    case WM_WINDOWPOSCHANGED:
+    case WM_SIZE:
+    case WM_MOVE:
+    case WM_MOVING:
+      if (uMsg == WM_TIMER && wParam == TIMER_OSD_ID) {
+        hideOSD();
+        return 0;
+      }
+      EnterCriticalSection(&m_cs);
+      if(m_video_output) m_video_output->timerCallback();
+      LeaveCriticalSection(&m_cs);
+      if (uMsg == WM_TIMER) return 0;
+    break;
+
+    case WM_LBUTTONDOWN:
+      if(is_fs) 
+        osdHitTest(LOWORD(lParam),HIWORD(lParam),0);
+#ifdef ACTIVEX_CONTROL
+	  SendMessage( video_hwnd, STATUS_MSG, STATUS_MOUSEPRESS, 1 );
+#endif
+      break;
+      
+    case WM_PAINT:
+      {
+        if (m_video_output && m_video_output->onPaint(hwnd,(HDC)wParam)) return 0;
+        if (m_logo && !m_video_output) 
+        {
+          PAINTSTRUCT p;
+          BeginPaint(hwnd,&p);
+
+          RECT r;
+          GetClientRect(hwnd,&r);
+          
+          HDC out=p.hdc;
+
+          HDC dc=CreateCompatibleDC(NULL);
+          SelectObject(dc,m_logo);
+          int xp=(r.right-r.left-m_logo_w)/2;
+          int yp=(r.bottom-r.top-m_logo_h)/2;
+          BitBlt(out,xp,yp,m_logo_w,m_logo_h,dc,0,0,SRCCOPY);
+
+          int bs=m_bufferstate;
+          if (bs < 16) bs=16;
+
+
+          HGDIOBJ oldobj1=SelectObject(out,CreateSolidBrush(RGB(0,0,0)));
+          HGDIOBJ oldobj2=SelectObject(out,CreatePen(PS_SOLID,0,RGB(0,0,0)));
+          Rectangle(out,r.left,r.top,r.right,yp);
+          if (m_statusmsg)
+            Rectangle(out,r.left,yp+m_logo_h,r.right,r.bottom);
+          else
+          {
+            Rectangle(out,r.left,yp+m_logo_h+2+9,r.right,r.bottom);
+            Rectangle(out,xp + ((bs * (m_logo_w+2))>>8),yp+m_logo_h+2,r.right, yp+9+m_logo_h+2);
+          }
+          Rectangle(out,r.left,yp,xp-1,yp+m_logo_h+9+2);
+          Rectangle(out,xp+m_logo_w+1,yp,r.right,yp+m_logo_h+2);
+          DeleteObject(SelectObject(out,oldobj2));
+          DeleteObject(SelectObject(out,oldobj1));
+
+          if (m_statusmsg)
+          {
+            RECT subr={0,yp+m_logo_h+2,r.right,r.bottom};
+            SetTextColor(out,RGB(255,255,255));
+            SetBkMode(out,TRANSPARENT);
+            DrawText(out,m_statusmsg,-1,&subr,DT_TOP|DT_CENTER|DT_NOCLIP|DT_NOPREFIX);
+          }
+          else
+          {
+            yp+=m_logo_h+2;
+            if (bs) 
+            {
+              HGDIOBJ oldobj1=SelectObject(out,CreateSolidBrush(RGB(128,128,128)));
+              HGDIOBJ oldobj2=SelectObject(out,CreatePen(PS_SOLID,0,RGB(255,255,255)));
+              Rectangle(out,xp-1,yp,xp + ((bs * (m_logo_w+2))>>8), yp+9);
+              DeleteObject(SelectObject(out,oldobj2));
+              DeleteObject(SelectObject(out,oldobj1));
+            }
+          }
+          DeleteDC(dc);
+          EndPaint(hwnd,&p);
+          return 0;
+        }
+      }
+      break;
+
+    case WM_USER+0x1:
+      m_need_change=1;
+      break;
+
+#ifdef ACTIVEX_CONTROL
+	case STATUS_MSG:
+	  SendStatus( wParam, lParam );
+	  break;
+#endif
+
+    case WM_KEYDOWN:
+      if(wParam==27 && is_fs) remove_fullscreen();
+      break;
+
+    case WM_MOUSEMOVE:
+      if(is_fs) {
+        if (ignore_mousemove_count>0) {
+          ignore_mousemove_count--;
+        }
+        else if (abs(osdLastMouseX - LOWORD(lParam)) + abs(osdLastMouseY - HIWORD(lParam)) > 1) {
+          KillTimer(hwnd, TIMER_OSD_ID);
+          showOSD();
+          SetTimer(hwnd, TIMER_OSD_ID, 2000, NULL);
+
+          if (wParam & MK_LBUTTON)
+            osdHitTest(LOWORD(lParam),HIWORD(lParam),1);
+          else
+            osdHitTest(LOWORD(lParam),HIWORD(lParam),-1);
+        }
+        osdLastMouseX = LOWORD(lParam);
+        osdLastMouseY = HIWORD(lParam);
+      }
+      break;
+  }
+  if (m_msgcallback)
+  {
+    return m_msgcallback(m_msgcallback_tok,hwnd, uMsg, wParam, lParam);
+  }
+ 
+	return (DefWindowProc(hwnd, uMsg, wParam, lParam));
+}
+
+VideoOutput::VideoOutput(HWND parent_hwnd, int initxpos, int initypos)
+{
+  curSubtitle=NULL;
+  m_statusmsg=0;
+  m_bufferstate=0;
+  m_msgcallback=0;
+  m_msgcallback_tok=0;
+  video_hwnd=video_parent_hwnd=0;
+  decoder=0;
+
+  vid_aspectadj=true;
+  vid_overlays=true;
+  vid_ddraw=true;
+  vid_vsync=true;
+  aspect=1.0;
+  m_need_change=false;
+
+  width=height=flip=uyvy_output=yuy2_output=is_fs=ignore_mousemove_count=show_osd=0;
+  oldfsparent=0;
+  memset(&oldfsrect,0,sizeof(oldfsrect));
+  memset(&lastfsrect,0,sizeof(lastfsrect));
+  oldfsstyle=0;
+
+  m_video_output=NULL;
+
+  osdFontText=NULL;
+  osdFontSymbol=NULL;
+  osdProgressBrushBg=NULL;
+  osdProgressBrushFg=NULL;
+  osdProgressPenBg=NULL;
+  osdProgressPenFg=NULL;
+  osdProgressPenBgHilite=NULL;
+  osdBlackBrush=NULL;
+  osdMemDC=NULL;
+  osdMemBM=NULL;
+  osdOldBM=NULL;
+  osdMemBMW=0;
+  osdMemBMH=0;
+  osdLastMouseX=-1;
+  osdLastMouseY=-1;
+
+  for (int i=0; i<NUM_WIDGETS; i++)
+    SetRect(&ctrlrect[i], 0, 0, 0, 0);
+  ctrlrects_ready = 0;
+
+  resetSubtitle();
+
+	WNDCLASS wc={0,};	
+
+  wc.hCursor=LoadCursor(NULL,IDC_ARROW);
+	wc.lpfnWndProc = WndProc;
+	wc.hInstance = GetModuleHandle(NULL);
+	wc.lpszClassName = "NSVplay";
+  LOGBRUSH lb={BS_SOLID,RGB(OV_COL_R,OV_COL_G,OV_COL_B),};
+  wc.hbrBackground=CreateBrushIndirect(&lb);
+	if (!class_refcnt) RegisterClass(&wc);
+  class_refcnt++;
+
+  m_logo=(HBITMAP)LoadImage(g_hInstance,MAKEINTRESOURCE(g_bitmap_id),IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION);
+  BITMAP bm;
+  GetObject(m_logo, sizeof(BITMAP), &bm);
+  m_logo_w=bm.bmWidth;
+  m_logo_h=bm.bmHeight;
+  if(m_logo_h<0) m_logo_h=-m_logo_h;
+
+  InitializeCriticalSection(&m_cs);
+
+  video_hwnd=CreateWindowEx(0,wc.lpszClassName, "NSV Player",parent_hwnd?WS_CHILD:(WS_OVERLAPPEDWINDOW&(~WS_MAXIMIZEBOX)),
+					initxpos,initypos,320,200,
+					parent_hwnd, NULL,wc.hInstance,(void*)this);
+
+  video_parent_hwnd=parent_hwnd;
+
+  m_lastbufinvalid=0;
+  
+#ifdef ACTIVEX_CONTROL
+  m_firstframe = 1;
+#endif
+}
+
+VideoOutputChild *VideoOutput::createVideoOutput(int n) {
+  if(!vid_overlays && !vid_ddraw) vid_overlays=true;
+
+  if(!vid_overlays) n++;
+  if(n==0) return new OverlayVideoOutput();
+  if(!vid_ddraw) n++;
+  if(n==1) return new DDrawVideoOutput();
+
+  return 0;
+}
+
+int VideoOutput::open(int w, int h, int vflip, double aspectratio, unsigned int fmt)
+{
+  EnterCriticalSection(&m_cs);
+  delete(m_video_output);
+  m_video_output=NULL;
+
+  if (!w) w=320;
+  if (!h) h=240;
+  width=w;
+  height=h;
+  flip=vflip;
+  type=fmt;
+  is_fs=0;
+  ignore_mousemove_count=0;
+  show_osd=0;
+  aspect=aspectratio;
+
+  for(int i=0;m_video_output=createVideoOutput(i);i++) {
+    if(m_video_output->create(this,w,h,fmt,vflip,aspectratio)) {
+      LeaveCriticalSection(&m_cs);
+      if (!GetParent(video_hwnd)) {
+        RECT r,r2;
+        int ow=width,oh=height;
+        if (aspect > 0.001)
+        {
+          if (aspect < 1.0) ow=(int)(ow/aspect);
+          else oh=(int)(oh*aspect);
+        }
+        GetWindowRect(video_hwnd,&r);
+        GetClientRect(video_hwnd,&r2);
+        SetWindowPos(video_hwnd,NULL,0,0,
+          ow+(r.right-r.left)-(r2.right-r2.left),
+          oh+(r.bottom-r.top)-(r2.bottom-r2.top),
+          SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
+      }
+      return 0;
+    }
+    delete(m_video_output);
+  }
+  LeaveCriticalSection(&m_cs);
+  return 1;
+}
+
+void VideoOutput::draw(void *frame)
+{
+  if (!m_video_output || !frame) return;
+  if ((m_video_output && m_video_output->needChange()) || m_need_change) {
+    open(width,height,flip,aspect,type);
+    m_need_change=0;
+  }
+#ifdef ACTIVEX_CONTROL
+  if ( m_firstframe ) {
+	m_firstframe = 0;
+	PostMessage( video_hwnd, STATUS_MSG, STATUS_FIRSTFRAME, 1 );
+  }
+#endif
+  if (m_video_output) m_video_output->displayFrame((const char *)frame,0,0);
+}
+
+VideoOutput::~VideoOutput()
+{
+  free(m_statusmsg);
+  delete(m_video_output);
+  DestroyWindow(video_hwnd);
+  if (!--class_refcnt) UnregisterClass("NSVplay",GetModuleHandle(NULL));
+  if(osdFontText) DeleteObject(osdFontText);
+  if(osdFontSymbol) DeleteObject(osdFontSymbol);
+  if(osdProgressBrushBg) DeleteObject(osdProgressBrushBg);
+  if(osdProgressBrushFg) DeleteObject(osdProgressBrushFg);
+  if(osdBlackBrush     ) DeleteObject(osdBlackBrush     );
+  if(osdProgressPenBg  ) DeleteObject(osdProgressPenBg  );
+  if(osdProgressPenFg  ) DeleteObject(osdProgressPenFg  );
+  if(osdProgressPenBgHilite) DeleteObject(osdProgressPenBgHilite);
+  if(osdMemDC) {
+	  SelectObject(osdMemDC,osdOldBM);	// delete our doublebuffer
+	  DeleteDC(osdMemDC);
+  }
+  if(osdMemBM) DeleteObject(osdMemBM);	
+
+
+  DeleteCriticalSection(&m_cs);
+}
+
+void VideoOutput::close()
+{
+  delete(m_video_output);
+  m_video_output=NULL;
+}
+
+void VideoOutput::getViewport(RECT *r, HWND wnd, int full) {
+  POINT *p=NULL;
+  RECT *sr=NULL; 
+	if (p || sr || wnd) {
+	  HINSTANCE h=LoadLibrary("user32.dll");
+	  if (h) {
+			HMONITOR (WINAPI *Mfp)(POINT pt, DWORD dwFlags) = (HMONITOR (WINAPI *)(POINT,DWORD)) GetProcAddress(h,"MonitorFromPoint");
+      HMONITOR (WINAPI *Mfr)(LPCRECT lpcr, DWORD dwFlags) = (HMONITOR (WINAPI *)(LPCRECT, DWORD)) GetProcAddress(h, "MonitorFromRect");
+      HMONITOR (WINAPI *Mfw)(HWND wnd, DWORD dwFlags)=(HMONITOR (WINAPI *)(HWND, DWORD)) GetProcAddress(h, "MonitorFromWindow");
+      BOOL (WINAPI *Gmi)(HMONITOR mon, LPMONITORINFO lpmi) = (BOOL (WINAPI *)(HMONITOR,LPMONITORINFO)) GetProcAddress(h,"GetMonitorInfoA");    
+			if (Mfp && Mfr && Mfw && Gmi) {
+			  HMONITOR hm = NULL;
+			  if (p)
+				  hm=Mfp(*p,MONITOR_DEFAULTTONULL);
+				else if (sr)
+				  hm=Mfr(sr,MONITOR_DEFAULTTONULL);
+				else if (wnd)
+				  hm=Mfw(wnd,MONITOR_DEFAULTTONULL);
+        if (hm) {
+          MONITORINFOEX mi;
+          memset(&mi,0,sizeof(mi));
+          mi.cbSize=sizeof(mi);
+
+          if (Gmi(hm,&mi)) {
+            if(!full) *r=mi.rcWork;
+            else *r=mi.rcMonitor;
+            FreeLibrary(h);
+            return;
+          }          
+        }
+			}
+			FreeLibrary(h);
+		}
+	}
+  if (full)
+  { // this might be borked =)
+    r->top=r->left=0;
+    r->right=::GetSystemMetrics(SM_CXSCREEN);
+    r->bottom=::GetSystemMetrics(SM_CYSCREEN);
+  }
+  else
+  {
+    SystemParametersInfo(SPI_GETWORKAREA,0,r,0);
+  }
+}
+
+void VideoOutput::fullscreen()
+{
+  if (is_fs) return;
+  if(!m_video_output) return;
+  is_fs=1; 
+  ignore_mousemove_count=2;
+
+  oldfsparent=GetParent(video_hwnd);
+  oldfsstyle=GetWindowLong(video_hwnd,GWL_STYLE);
+  if (!oldfsparent) GetWindowRect(video_hwnd,&oldfsrect);
+  else GetClientRect(video_hwnd,&oldfsrect);
+  getViewport(&lastfsrect,video_hwnd,1);
+
+  SetParent(video_hwnd,NULL);
+  SetWindowLong(video_hwnd,GWL_STYLE,WS_POPUP|WS_VISIBLE);
+  SetWindowPos(video_hwnd, HWND_TOPMOST, lastfsrect.left, lastfsrect.top, lastfsrect.right-lastfsrect.left, lastfsrect.bottom-lastfsrect.top, SWP_DRAWFRAME);
+  SetFocus(video_hwnd);
+
+  resetSubtitle();
+
+  //showOSD();
+
+  //SetCursor(NULL);
+}
+
+void VideoOutput::getOutputSize(int *w, int *h)
+{
+  RECT r2;
+  GetClientRect(video_hwnd,&r2);
+  *w=r2.right-r2.left;
+  *h=r2.bottom-r2.top;
+}
+
+void VideoOutput::setOutputSize(int w, int h)
+{
+  RECT r,r2;
+  GetWindowRect(video_hwnd,&r);
+  GetClientRect(video_hwnd,&r2);
+  SetWindowPos(video_hwnd, 0, 0,0, 
+          w+(r.right-r.left)-(r2.right-r2.left),
+          h+(r.bottom-r.top)-(r2.bottom-r2.top),  
+      SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
+}
+
+void VideoOutput::remove_fullscreen()
+{
+  if(!is_fs) return;
+
+  SetParent(video_hwnd,oldfsparent);
+  SetWindowLong(video_hwnd,GWL_STYLE,oldfsstyle);
+  // note: when returning from fullscreen *on a secondary monitor*,
+  //       be careful how you set the new window Z order.
+  //   nsvplay.exe:  only HWND_NOTOPMOST works
+  //   nsvplayX.exe: only HWND_TOP works
+  SetWindowPos(video_hwnd, oldfsparent ? HWND_TOP : HWND_NOTOPMOST, oldfsrect.left, oldfsrect.top, oldfsrect.right-oldfsrect.left, oldfsrect.bottom-oldfsrect.top, SWP_FRAMECHANGED);
+  SetFocus(oldfsparent ? oldfsparent : video_hwnd);
+
+  is_fs=0;
+  show_osd=0;
+  ctrlrects_ready=0;
+  resetSubtitle();
+
+  hideOSD();
+}
+
+int VideoOutput::is_fullscreen()
+{
+  return is_fs;
+}
+
+void VideoOutput::showStatusMsg(const char *text)
+{
+  m_statusmsg=_strdup(text);
+  InvalidateRect(video_hwnd,NULL,TRUE); 
+}
+
+void VideoOutput::drawSubtitle(SubsItem *item)
+{
+  if(!item) {
+    if(curSubtitle) {
+      m_video_output->drawSubtitle(NULL);
+      curSubtitle=NULL;
+    }
+    return;
+  }
+
+  if(curSubtitle==item) return;
+
+  curSubtitle=item;
+
+  m_video_output->drawSubtitle(curSubtitle);
+}
+
+void VideoOutput::resetSubtitle()
+{
+  curSubtitle=NULL;
+  if(m_video_output) m_video_output->resetSubtitle();
+}
+
+void VideoOutput::showOSD() {
+  if(OSD_ENABLED && m_video_output) {
+    KillTimer(video_hwnd, TIMER_OSD_ID);
+    if (!show_osd) 
+      m_video_output->showOSD();
+    SetTimer(video_hwnd, TIMER_OSD_ID, 2000, NULL);
+    show_osd = 1;
+    SetCursor(LoadCursor(NULL, IDC_ARROW));
+  }
+}
+
+void VideoOutput::hideOSD() {
+  if(OSD_ENABLED && m_video_output) {
+    KillTimer(video_hwnd, TIMER_OSD_ID);
+    m_video_output->hideOSD();
+    show_osd = 0;
+    SetCursor(NULL);
+  }
+}
+
+void VideoOutput::drawOSD(HDC hdc, RECT *rg) {
+  if(m_video_output && show_osd) {
+
+    if (!osdMemDC          ) osdMemDC           = CreateCompatibleDC(hdc);
+    if (!osdFontText)   osdFontText=CreateFont(OSD_TEXT_SIZE,0,0,0,FW_SEMIBOLD,FALSE,FALSE,FALSE,ANSI_CHARSET,OUT_OUTLINE_PRECIS,CLIP_DEFAULT_PRECIS,ANTIALIASED_QUALITY,DEFAULT_PITCH|FF_DONTCARE,"Arial");
+    if (!osdFontSymbol) osdFontSymbol=CreateFont(OSD_TEXT_SIZE,0,0,0,FW_NORMAL,FALSE,FALSE,FALSE,SYMBOL_CHARSET,OUT_OUTLINE_PRECIS,CLIP_DEFAULT_PRECIS,ANTIALIASED_QUALITY,DEFAULT_PITCH,"Webdings");
+    if (!osdProgressBrushBg) osdProgressBrushBg = CreateSolidBrush(RGB(OSD_VOL_BKCOL_R,OSD_VOL_BKCOL_G,OSD_VOL_BKCOL_B));
+    if (!osdProgressBrushFg) osdProgressBrushFg = CreateSolidBrush(RGB(OSD_VOL_COL_R,OSD_VOL_COL_G,OSD_VOL_COL_B));
+    if (!osdBlackBrush     ) osdBlackBrush      = CreateSolidBrush(RGB(0,0,0));//OV_COL_R,OV_COL_G,OV_COL_B));
+    if (!osdProgressPenBg  ) osdProgressPenBg   = CreatePen(PS_SOLID,0,RGB(OSD_TEXT_R,OSD_TEXT_G,OSD_TEXT_B));
+    if (!osdProgressPenFg  ) osdProgressPenFg   = CreatePen(PS_NULL,0,RGB(0,0,0));
+    if (!osdProgressPenBgHilite) osdProgressPenBgHilite = CreatePen(PS_SOLID,0,RGB(OSD_TEXT_R_HILITE,OSD_TEXT_G_HILITE,OSD_TEXT_B_HILITE));
+    
+    COLORREF fg = GetTextColor(osdMemDC);
+    COLORREF bg = GetBkColor(osdMemDC);
+    SetTextColor(osdMemDC, RGB(OSD_TEXT_R,OSD_TEXT_G,OSD_TEXT_B));
+    SetBkColor(osdMemDC, RGB(0,0,0));//OV_COL_R,OV_COL_G,OV_COL_B));
+    
+    HGDIOBJ oldfont  = SelectObject(osdMemDC, osdFontText);
+    HGDIOBJ oldbrush = SelectObject(osdMemDC, osdProgressBrushBg);
+    HGDIOBJ oldpen   = SelectObject(osdMemDC, osdProgressPenBg);
+
+    RECT fullr;
+    GetClientRect(video_hwnd,&fullr);
+    ClientToScreen(video_hwnd,(LPPOINT)&fullr);
+    ClientToScreen(video_hwnd,((LPPOINT)&fullr) + 1);
+    // transform coords from windows desktop coords (where 0,0==upper-left corner of the primary monitor)
+    // to the coords for the monitor we're displaying on:
+    fullr.top -= m_video_output->m_mon_y;
+    fullr.left -= m_video_output->m_mon_x;
+    fullr.right -= m_video_output->m_mon_x;
+    fullr.bottom -= m_video_output->m_mon_y;
+
+    if (!ctrlrects_ready) {
+      ctrlrects_ready = 1;
+
+      int net_width = 0;
+      int max_height = 0;
+      int streaming = (decoder && decoder->getlen()==-1) ? 1 : 0;
+      
+      for (int i=0; i<NUM_WIDGETS; i++) {
+        if (streaming && (i==CTRL_PROGRESS || i==CTRL_PROGRESSTEXT || i==CTRL_PROGRESSSPACER || i==CTRL_FFWD || i==CTRL_REW)) {
+          // disable progress bar + seek arrows when the NSV is a stream
+          ctrlrect[i].right = -1;
+          continue;
+        }
+        else if (g_ctrl_force_width[i] != 0) {
+          SetRect(&ctrlrect[i], 0, 0, g_ctrl_force_width[i], 0);
+        }
+        else {
+          SelectObject(osdMemDC, (g_ctrl_type[i] == CTRLTYPE_SYMBOL) ? osdFontSymbol : osdFontText);
+          SetRect(&ctrlrect[i], 0, 0, 256, 256);
+          ctrlrect[i].bottom = DrawText(osdMemDC, g_ctrl_text[i], -1, &ctrlrect[i], DT_SINGLELINE|DT_CALCRECT);
+        }
+        net_width += ctrlrect[i].right - ctrlrect[i].left;
+        max_height = max(max_height, ctrlrect[i].bottom - ctrlrect[i].top);
+      }
+
+      // now we know the size of all the controls; now place them.
+      int x = (fullr.right + fullr.left)/2 - net_width/2;
+      SetRect(&ctrlrect_all, 0, 0, 0, 0);
+      for (i=0; i<NUM_WIDGETS; i++)
+      {
+        if (ctrlrect[i].right >= 0) // if control is not disabled...
+        {
+          int this_width  = ctrlrect[i].right  - ctrlrect[i].left;
+          int this_height = ctrlrect[i].bottom - ctrlrect[i].top ;
+          if (this_height==0) this_height = max_height*2/3;// progress bars
+          ctrlrect[i].top    = max_height/2 - this_height/2;
+          ctrlrect[i].bottom = max_height/2 + this_height/2;
+          ctrlrect[i].left   = x;
+          ctrlrect[i].right  = x + this_width;
+          if (ctrlrect_all.bottom==0) {
+            ctrlrect_all.top    = ctrlrect[i].top   ;
+            ctrlrect_all.bottom = ctrlrect[i].bottom;
+          } 
+          else {
+            ctrlrect_all.top    = min(ctrlrect_all.top   , ctrlrect[i].top   );
+            ctrlrect_all.bottom = max(ctrlrect_all.bottom, ctrlrect[i].bottom);
+          }
+          x += this_width;
+        }
+      }     
+    }
+
+    int w = fullr.right - fullr.left;
+    int h = ctrlrect_all.bottom - ctrlrect_all.top;
+    if (!osdMemBM || osdMemBMW != w || osdMemBMH != h) {
+      if (osdMemBM) {
+	      SelectObject(osdMemDC,osdOldBM);	
+        DeleteObject(osdMemBM);	
+      }
+      osdMemBM = CreateCompatibleBitmap(hdc,w,h);
+      osdOldBM = (HBITMAP)SelectObject(osdMemDC, osdMemBM);
+      osdMemBMW = w;
+      osdMemBMH = h;
+    }
+
+    RECT temp;
+    SetRect(&temp, 0, 0, w, h);
+    FillRect(osdMemDC, &temp, (HBRUSH)osdBlackBrush);
+
+    for (int i=0; i<NUM_WIDGETS; i++) {
+      if (g_ctrl_type[i] == CTRLTYPE_PROGRESS)
+      {
+        int progress = 0;
+        int max_progress = ctrlrect[i].right - ctrlrect[i].left;
+        switch(i)
+        {
+        case CTRL_VOL: 
+          if (decoder)
+            progress = decoder->getvolume()*max_progress/255; 
+          break;
+        case CTRL_PROGRESS: 
+          if (decoder)
+          {
+            int len = decoder->getlen();
+            if (len>0)
+              progress = decoder->getpos()*max_progress/len;
+          }
+          break;
+        }
+
+        SelectObject(osdMemDC, osdProgressBrushBg);
+        SelectObject(osdMemDC, (i==osdLastClickItem) ? osdProgressPenBgHilite : osdProgressPenBg);
+        RoundRect(osdMemDC, ctrlrect[i].left, ctrlrect[i].top, ctrlrect[i].right, ctrlrect[i].bottom, 3, 3);
+        SelectObject(osdMemDC, osdProgressBrushFg);
+        SelectObject(osdMemDC, osdProgressPenFg);
+        Rectangle(osdMemDC, ctrlrect[i].left+1, ctrlrect[i].top+1, ctrlrect[i].left + progress, ctrlrect[i].bottom);
+      }
+      else if (g_ctrl_type[i] == CTRLTYPE_SYMBOL ||
+               g_ctrl_type[i] == CTRLTYPE_TEXT)
+      {
+        SelectObject(osdMemDC, (g_ctrl_type[i] == CTRLTYPE_SYMBOL) ? osdFontSymbol : osdFontText);
+        SetTextColor(osdMemDC, (i==osdLastClickItem) ? RGB(OSD_TEXT_R_HILITE,OSD_TEXT_G_HILITE,OSD_TEXT_B_HILITE) : RGB(OSD_TEXT_R,OSD_TEXT_G,OSD_TEXT_B));
+        DrawText(osdMemDC, g_ctrl_text[i], -1, &ctrlrect[i], DT_SINGLELINE);
+      }
+    }
+
+    int x0 = fullr.left;
+    int y0 = fullr.bottom - (ctrlrect_all.bottom - ctrlrect_all.top);
+    BitBlt(hdc,x0,y0,w,h,osdMemDC,0,0,SRCCOPY);
+
+    // display stream title @ the top:
+#if (SHOW_STREAM_TITLE_AT_TOP)
+    if (decoder)
+    {
+      RECT temp;
+      SetRect(&temp, 0, 0, w, h);
+      FillRect(osdMemDC, &temp, (HBRUSH)osdBlackBrush);
+
+      SelectObject(osdMemDC, osdFontText);
+      SetTextColor(osdMemDC, RGB(OSD_TEXT_R,OSD_TEXT_G,OSD_TEXT_B));
+      char *t=decoder->getTitle();
+      char *buf=(char*)malloc(32+(t?strlen(t):0));
+
+      wsprintf(buf, "%s (%d kbps)", t?t:"", decoder->getBitrate()/1000);
+      char *p=buf;
+      while (*p)
+      {
+        if (*p == '_') *p=' ';
+        p++;
+      }
+      DrawText(osdMemDC, buf, -1, &temp, DT_SINGLELINE|DT_CENTER);
+      free(buf);
+
+      SelectObject(osdMemDC, osdFontSymbol);
+      DrawText(osdMemDC, "2r", -1, &temp, DT_SINGLELINE|DT_RIGHT);
+
+      int x0 = fullr.left;
+      int y0 = fullr.top;
+      BitBlt(hdc,x0,y0,w,h,osdMemDC,0,0,SRCCOPY);
+    }
+
+    SelectObject(osdMemDC, oldpen);
+    SelectObject(osdMemDC, oldbrush);
+    SelectObject(osdMemDC, oldfont);
+    SetTextColor(osdMemDC, fg);
+    SetBkColor(osdMemDC, bg);
+  }
+#endif
+
+}
+
+void VideoOutput::osdHitTest(int x, int y, int dragging)
+{ 
+  // dragging == -1: just a mousemove (no clicking)
+  // dragging ==  0: user clicked
+  // dragging ==  1: user clicked before, and is now dragging/moving mouse
+
+  if (dragging<1)
+    osdLastClickItem = -1;
+
+  // transform (x,y) from screen coords into coords relative to the memDC
+  y = y - ((lastfsrect.bottom - lastfsrect.top) - (ctrlrect_all.bottom - ctrlrect_all.top));
+
+  int i0 = 0;
+  int i1 = NUM_WIDGETS;
+  if (dragging==1) {
+    i0 = osdLastClickItem;
+    i1 = osdLastClickItem+1;
+  }
+
+  for (int i=i0; i<i1; i++)
+  {
+    if (dragging==1 || (x >= ctrlrect[i].left && x <= ctrlrect[i].right && y >= ctrlrect[i].top  && y <= ctrlrect[i].bottom))
+    {
+      float t = (x - ctrlrect[i].left) / (float)(ctrlrect[i].right - ctrlrect[i].left);
+      if (t<0) t=0;
+      if (t>1) t=1;
+      if (dragging<1)
+        osdLastClickItem = i;
+      
+      switch(i)
+      {
+      case CTRL_VOL:
+        if (decoder && dragging>=0) decoder->setvolume((int)(t*255));
+        return;
+      case CTRL_PROGRESS:
+        if (decoder && dragging>=0) 
+        {
+          int len = decoder->getlen();
+          if (len > 0)
+            decoder->seek((int)(t*len));
+        }
+        return;
+      case CTRL_PAUSE:
+        if (decoder && dragging>=0) decoder->pause(1);
+        return;
+      case CTRL_PLAY:
+        if (decoder && dragging>=0) decoder->pause(0);
+        return;
+      case CTRL_STOP:
+        if (decoder && dragging>=0) {
+          decoder->pause(1);
+          remove_fullscreen();
+        }
+        return;
+      case CTRL_REW:
+      case CTRL_FFWD:
+        if (decoder && dragging>=0) 
+        {
+          int pos = decoder->getpos();
+          int len = decoder->getlen();
+          if (len > 0)
+          {
+            if (i==CTRL_REW) 
+              pos = max(0, pos-15000);  // milliseconds to rewind
+            else
+              pos = min(len, pos+30000);  // milliseconds to skip ahead
+            decoder->seek(pos);
+          }
+        }
+        return;
+      default:
+        if (dragging<1)
+          osdLastClickItem = -1;
+        break;
+      }
+    }
+  }
+
+  if (dragging==0)
+    remove_fullscreen();
+}
diff --git a/Src/nsv/nsvplay/video.h b/Src/nsv/nsvplay/video.h
new file mode 100644
index 00000000..535cee24
--- /dev/null
+++ b/Src/nsv/nsvplay/video.h
@@ -0,0 +1,160 @@
+#ifndef _VIDEO_H
+#define _VIDEO_H
+
+#include <windows.h>
+#include <ddraw.h>
+#include <multimon.h>
+
+#include "main.h"
+
+#define NUM_WIDGETS 11
+
+class VideoOutput;
+class SubsItem;
+
+class VideoOutputChild {
+public:
+  VideoOutputChild() { m_mon_x=m_mon_y=0; }
+  virtual ~VideoOutputChild() { }
+  
+  virtual int create(VideoOutput *parent, int w, int h, unsigned int type, int flipit, double aspectratio)=0; //return 1 if ok
+  virtual int needChange()=0; //return 1 if need to renegociate video output
+
+  virtual int onPaint(HWND hwnd, HDC hdc) { return 0; } //return 1 if override
+  virtual void displayFrame(const char *buf, int size, int time)=0;
+
+  virtual void goFullScreen()=0;
+  virtual void removeFullScreen()=0;
+  virtual int showOSD() { return 0; }
+  virtual void hideOSD() { }
+
+  virtual void timerCallback() { }
+
+  virtual void setPalette(RGBQUAD *pal) { }
+
+  virtual void drawSubtitle(SubsItem *item) { }
+  virtual void resetSubtitle() { }
+
+  char m_szTest[512];
+  
+  void update_monitor_coords(VideoOutput *parent);
+  int  m_mon_x;
+  int  m_mon_y;
+  int  m_found_devguid;
+  GUID m_devguid;
+  HMONITOR m_monitor_to_find;
+};
+
+#include "vid_overlay.h"
+#include "vid_ddraw.h"
+
+class VideoOutput : public IVideoOutput {
+  public:
+    VideoOutput(HWND parent_hwnd=NULL, int initxpos=CW_USEDEFAULT, int initypos=CW_USEDEFAULT);
+    ~VideoOutput();
+    int open(int w, int h, int vflip, double aspectratio, unsigned int fmt);
+    void close();
+    void draw(void *frame);
+    void drawSubtitle(SubsItem *item);
+    void showStatusMsg(const char *text);
+    void notifyBufferState(int bufferstate); /* 0-255*/
+    int get_latency();
+    void setcallback(LRESULT (*msgcallback)(void *token, HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam), void *token) { m_msgcallback_tok=token; m_msgcallback=msgcallback; }
+    void setNSVDecoder(NSVDecoder *nsv_decoder) { decoder = nsv_decoder; }
+
+    void fullscreen();
+    void remove_fullscreen();
+    int is_fullscreen();
+
+    HWND getHwnd() { return video_hwnd; }
+
+    void adjustAspect(RECT &rd);
+
+    int vid_vsync;
+    int vid_aspectadj;
+    int vid_overlays;
+    int vid_ddraw;
+
+    void getViewport(RECT *r, HWND wnd, int full);
+    void setOutputSize(int w, int h);
+    void getOutputSize(int *w, int *h);
+
+    int  osdShowing() { return show_osd; }
+    int  osdReady()   { return ctrlrects_ready; }
+    void showOSD();
+    void hideOSD();
+    void drawOSD(HDC hdc, RECT *r);
+    int  getOSDbarHeight() { return (show_osd && ctrlrects_ready) ? (ctrlrect_all.bottom - ctrlrect_all.top) : 0; }; 
+
+  private:
+
+
+    LRESULT WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+    static int class_refcnt;
+
+    static LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+
+    HWND video_hwnd, video_parent_hwnd;
+    NSVDecoder *decoder;
+
+    double aspect;
+    int width, height, flip;
+    unsigned int type;
+    int uyvy_output,yuy2_output;
+    int i420_output;
+    int is_fs;
+    int ignore_mousemove_count;
+    int show_osd;
+    HWND oldfsparent;
+    RECT oldfsrect;  // the old window rect, BEFORE fullscreen mode was entered
+    RECT lastfsrect; // the most recent bounding rect when in fullscreen mode
+    LONG oldfsstyle;
+
+    int m_bufferstate;
+    void resetSubtitle();
+    SubsItem *curSubtitle;
+    
+    // ONSCREEN DISPLAY (osd):
+    HFONT osdFontText;
+    HFONT osdFontSymbol;
+    HGDIOBJ osdProgressBrushBg;
+    HGDIOBJ osdProgressBrushFg;
+    HGDIOBJ osdProgressPenBg;
+    HGDIOBJ osdProgressPenFg;
+    HGDIOBJ osdProgressPenBgHilite;
+    HGDIOBJ osdBlackBrush;
+    void osdHitTest(int x, int y, int dragging);
+    int osdLastClickItem;
+    HDC     osdMemDC;	 // memory device context
+    HBITMAP	osdMemBM;  // memory bitmap (for memDC)
+    HBITMAP osdOldBM;  // old bitmap (from memDC)
+    int     osdMemBMW; // width of memory bitmap
+    int     osdMemBMH; // height of memory bitmap
+    int     osdLastMouseX;  // for WM_MOUSEMOVE thresholding, so osd isn't spastic
+    int     osdLastMouseY;  // for WM_MOUSEMOVE thresholding, so osd isn't spastic
+    RECT    ctrlrect[NUM_WIDGETS]; // relative to [i.e. (0,0) is] upper left corner of the black strip @ the bottom
+    RECT    ctrlrect_all;          // relative to [i.e. (0,0) is] upper left corner of the black strip @ the bottom
+    int     ctrlrects_ready;
+
+    LRESULT (*m_msgcallback)(void *token, HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+    void *m_msgcallback_tok;
+
+    VideoOutputChild *m_video_output;
+    VideoOutputChild *createVideoOutput(int n);
+
+    CRITICAL_SECTION m_cs;
+    char *m_statusmsg;
+
+    int m_need_change;
+
+    HBITMAP m_logo;
+    int m_logo_w, m_logo_h;
+
+    DWORD m_lastbufinvalid;
+
+#ifdef ACTIVEX_CONTROL
+	int m_firstframe;
+#endif
+};
+
+#endif
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/vp3stub.cpp b/Src/nsv/nsvplay/vp3stub.cpp
new file mode 100644
index 00000000..8f6776c7
--- /dev/null
+++ b/Src/nsv/nsvplay/vp3stub.cpp
@@ -0,0 +1,120 @@
+#include "main.h"
+#include "../../vp32/include/duck_dxl.h"
+#include "vfw.h"
+
+extern "C" {
+  void GetImageBufs(DXL_XIMAGE_HANDLE x, YV12_PLANES *p);
+};
+
+int vp3_postprocess=0;
+int vp3_targetcpu=0;
+
+class VP3_Decoder : public IVideoDecoder {
+  public:
+    VP3_Decoder(int w, int h, int uvflip);
+    ~VP3_Decoder();
+    int decode(int need_kf, 
+            void *in, int in_len, 
+            void **out, // out is set to a pointer to data
+            unsigned int *out_type, // 'Y','V','1','2' is currently defined
+            int *is_kf);
+    void flush() { }
+
+  private:
+    int m_uvflip;
+    int l_tcpu, l_pp;
+    static int init;
+    DXL_XIMAGE_HANDLE xim;
+    YV12_PLANES vidbufdec;
+};
+
+int VP3_Decoder::init;
+
+VP3_Decoder::VP3_Decoder(int w, int h, int uvflip)
+{
+  l_tcpu=-1;
+  l_pp=-1;
+  if (!init)
+  {
+    init=1;
+    DXL_InitVideoEx(1,1);
+  }
+  m_uvflip=uvflip;
+  vidbufdec.y.baseAddr=0;
+  xim = DXL_AlterXImage( NULL, (unsigned char *)"" ,MAKEFOURCC('V','P','3','1'), DXRGBNULL,w,h);
+}
+
+VP3_Decoder::~VP3_Decoder()
+{
+  if ( xim ) DXL_DestroyXImage( xim);
+}
+
+
+int VP3_Decoder::decode(int need_kf, 
+        void *in, int in_len, 
+        void **out, // out is set to a pointer to data
+        unsigned int *out_type, // 'Y','V','1','2' is currently defined
+        int *is_kf)
+{
+  BYTE *data=(BYTE*)in;
+
+  if (!xim) return -1;
+
+  *out_type=NSV_MAKETYPE('Y','V','1','2');
+  
+  if (vp3_postprocess != l_pp || vp3_targetcpu != l_tcpu)
+  {
+    l_pp=vp3_postprocess;
+    l_tcpu=vp3_targetcpu;
+    if (l_pp)
+    {
+      int v=l_tcpu;
+      if (v < 1) v=1;
+      if (v > 100) v=100;
+      vp31_SetParameter(xim,1, v);
+      vp31_SetParameter(xim,0, 9);
+    }
+		else 
+    {
+      vp31_SetParameter(xim,1, 0);
+      vp31_SetParameter(xim,0, 0);
+    }
+  }
+
+  DXL_AlterXImageData( xim, data);
+  DXL_SetXImageCSize(xim, in_len);
+
+  *is_kf=!(!in_len || data[0] > 0x7f);
+
+  *out=NULL;
+
+  if ((need_kf && !*is_kf) || !in_len) 
+  {
+    return 0;
+  }
+
+	if (!DXL_dxImageToVScreen( xim, NULL))
+  {
+    GetImageBufs(xim,&vidbufdec);
+    if (m_uvflip)
+    {
+      YV12_PLANE tmp=vidbufdec.v;
+      vidbufdec.v=vidbufdec.u;
+      vidbufdec.u=tmp;
+    }
+    *out=&vidbufdec;
+    return 0;
+  }
+
+  return -1;
+}
+
+IVideoDecoder *VP3_CREATE(int w, int h, double framerate, unsigned int fmt, int *flip)
+{
+  if (fmt == NSV_MAKETYPE('V','P','3',' ') || fmt == NSV_MAKETYPE('V','P','3','1')) 
+  {
+    *flip=1;
+    return new VP3_Decoder(w,h,fmt == NSV_MAKETYPE('V','P','3',' '));
+  }
+  return NULL;
+}
diff --git a/Src/nsv/nsvplay/vp3stub.h b/Src/nsv/nsvplay/vp3stub.h
new file mode 100644
index 00000000..dacc9663
--- /dev/null
+++ b/Src/nsv/nsvplay/vp3stub.h
@@ -0,0 +1,11 @@
+#ifndef _VP3STUB_H_
+#define _VP3STUB_H_
+
+#include "main.h"
+
+extern int vp3_postprocess;
+extern int vp3_targetcpu;
+
+IVideoDecoder *VP3_CREATE(int w, int h, double framerate, unsigned int fmt, int *flip);
+
+#endif
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/vp5stub.cpp b/Src/nsv/nsvplay/vp5stub.cpp
new file mode 100644
index 00000000..9c49c359
--- /dev/null
+++ b/Src/nsv/nsvplay/vp5stub.cpp
@@ -0,0 +1,112 @@
+#include <windows.h>
+#include "../nsvlib.h"
+#include "../dec_if.h"
+
+#include "vfw.h"
+
+class VP5_Decoder : public IVideoDecoder {
+  public:
+    VP5_Decoder(int w, int h);
+    ~VP5_Decoder();
+    int decode(int need_kf, 
+            void *in, int in_len, 
+            void **out, // out is set to a pointer to data
+            unsigned int *out_type, // 'Y','V','1','2' is currently defined
+            int *is_kf);
+    void flush() { }
+
+    int m_err;
+
+  private:
+    int width,height;
+	  BITMAPINFO vp5_bmo,vp5_bmi;
+	  HIC vp5_hic;  
+    unsigned char *vidbufdec;
+};
+
+VP5_Decoder::VP5_Decoder(int w, int h)
+{
+  width=w;
+  height=h;
+  m_err=0;
+  vp5_hic=0;
+  vidbufdec=(unsigned char*)malloc(sizeof(YV12_PLANES) + w*h*3/2);
+    // init vp5 decode
+  memset((void *) &vp5_bmi,0,sizeof(BITMAPINFO));
+  memset((void *) &vp5_bmo,0,sizeof(BITMAPINFO));
+
+  vp5_bmi.bmiHeader.biCompression = mmioFOURCC('V','P','5','0'); 
+  vp5_bmi.bmiHeader.biHeight=h;
+  vp5_bmi.bmiHeader.biWidth =w;
+
+  vp5_bmo.bmiHeader.biCompression = mmioFOURCC('Y','V','1','2');
+  vp5_bmo.bmiHeader.biHeight=h;
+  vp5_bmo.bmiHeader.biWidth =w;
+  vp5_bmo.bmiHeader.biBitCount = 12;
+
+  vp5_hic = ICOpen(ICTYPE_VIDEO, vp5_bmi.bmiHeader.biCompression, ICMODE_DECOMPRESS);
+  vp5_bmo.bmiHeader.biHeight*=-1;
+  if(!vp5_hic || ICERR_OK !=ICDecompressBegin(vp5_hic, &vp5_bmi, &vp5_bmo))
+  {
+    m_err=1;
+    return;
+  }
+}
+
+VP5_Decoder::~VP5_Decoder()
+{
+  if (vp5_hic)
+  {
+    ICDecompressEnd(vp5_hic);
+  	ICClose(vp5_hic);
+  }
+  free(vidbufdec);
+}
+
+
+int VP5_Decoder::decode(int need_kf, 
+        void *in, int in_len, 
+        void **out, // out is set to a pointer to data
+        unsigned int *out_type, // 'Y','V','1','2' is currently defined
+        int *is_kf)
+{
+  *out_type=NSV_MAKETYPE('Y','V','1','2');
+  vp5_bmi.bmiHeader.biSizeImage = in_len;
+  if(ICERR_OK == ICDecompress(vp5_hic,0,(BITMAPINFOHEADER *) &vp5_bmi, (char*)in,(BITMAPINFOHEADER *) &vp5_bmo, (char*)vidbufdec+sizeof(YV12_PLANES)))
+  {
+    *is_kf=!(!in_len || ((unsigned char *)in)[0] > 0x7f);
+    if (need_kf && !*is_kf) 
+    {
+      return 0;
+    }
+    YV12_PLANES *image_vbd=(YV12_PLANES *)vidbufdec;
+    image_vbd->y.baseAddr=(unsigned char *)(image_vbd+1);
+    image_vbd->v.baseAddr=((unsigned char *)(image_vbd+1)) + width*height;
+    image_vbd->u.baseAddr=((unsigned char *)(image_vbd+1)) + width*height*5/4;
+    image_vbd->y.rowBytes=width;
+    image_vbd->v.rowBytes=width/2;
+    image_vbd->u.rowBytes=width/2;
+    *out=(void*)vidbufdec;
+
+    return 0;
+  }
+
+  return -1;
+
+}
+
+IVideoDecoder *VP5_CREATE(int w, int h, double framerate, unsigned int fmt, int *flip)
+{
+  if (fmt == NSV_MAKETYPE('V','P','5','0')) 
+  {
+    *flip=0;
+    VP5_Decoder *a=new VP5_Decoder(w,h);
+    if (a->m_err)
+    {
+      delete a;
+      return NULL;
+    }
+    return a;
+  }
+  return NULL;
+}
diff --git a/Src/nsv/nsvplay/vp5stub.h b/Src/nsv/nsvplay/vp5stub.h
new file mode 100644
index 00000000..55124650
--- /dev/null
+++ b/Src/nsv/nsvplay/vp5stub.h
@@ -0,0 +1,8 @@
+#ifndef _VP5STUB_H_
+#define _VP5STUB_H_
+
+#include "main.h"
+
+IVideoDecoder *VP5_CREATE(int w, int h, double framerate, unsigned int fmt, int *flip);
+
+#endif
\ No newline at end of file
diff --git a/Src/nsv/nsvplay/wndmenu.h b/Src/nsv/nsvplay/wndmenu.h
new file mode 100644
index 00000000..17677901
--- /dev/null
+++ b/Src/nsv/nsvplay/wndmenu.h
@@ -0,0 +1,388 @@
+#ifndef _WNDMENU_H_
+#define _WNDMENU_H_
+
+//need to define WNDMENU_CAPTION to the caption
+// you can define these to remove menu functionality
+//WNDMENU_NOABOUT // no about header
+//WNDMENU_NOVOLUME // no volume submenu
+//WNDMENU_NOINFO // no info submenu
+//WNDMENU_NOZOOM // no zoom 50/100/200/400
+//WNDMENU_NOZOOMFS // no zoom fullscreen
+//WNDMENU_NOOPTIONS // no options submenu
+//WNDMENU_NOPOSITIONSAVE // disables saving of position
+//WNDMENU_NOSUBTITLES // no subtitles submenu
+
+#ifndef ABS 
+#define ABS(x) ((x)<0?-(x):(x))
+#endif
+
+
+static void _ReadConfigItemInt(char *name, int *value)
+{
+  HKEY hKey;
+  if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,"Software\\Nullsoft\\NSVPlay",0,KEY_READ,&hKey) == ERROR_SUCCESS)
+  {
+    DWORD t,l=4;
+    int a;
+    if (RegQueryValueEx(hKey,name,NULL,&t,(unsigned char *)&a,&l ) == ERROR_SUCCESS && t == REG_DWORD)
+      *value=a;
+    RegCloseKey(hKey);
+  }
+}
+
+static void _WriteConfigItemInt(char *name, int value)
+{
+  HKEY hKey;
+  if (RegCreateKey(HKEY_LOCAL_MACHINE,"Software\\Nullsoft\\NSVPlay",&hKey) == ERROR_SUCCESS)
+  {
+    RegSetValueEx(hKey,name,0,REG_DWORD,(unsigned char*)&value,4);
+    RegCloseKey(hKey);
+  }
+}
+
+static void _InsertString(HMENU hMenu, int pos, char *string, int id, int checked=0, int disabled=0)
+{
+  MENUITEMINFO inf={sizeof(inf),MIIM_ID|MIIM_STATE|MIIM_TYPE,MFT_STRING,
+                    (checked?MFS_CHECKED:0) | (disabled?MFS_DISABLED:MFS_ENABLED), id,
+                    };
+  inf.dwTypeData = string;
+
+  InsertMenuItem(hMenu,pos,TRUE,&inf);
+}
+
+static void _InsertSep(HMENU hMenu, int pos)
+{
+  MENUITEMINFO inf={sizeof(inf),MIIM_TYPE,MFT_SEPARATOR };
+  InsertMenuItem(hMenu,pos,TRUE,&inf);
+}
+
+static HMENU _InsertSub(HMENU hMenu, int pos, char *string)
+{
+  MENUITEMINFO inf={sizeof(inf),MIIM_TYPE|MIIM_SUBMENU,MFT_STRING };
+  inf.dwTypeData = string;
+  inf.hSubMenu=CreatePopupMenu();
+  InsertMenuItem(hMenu,pos,TRUE,&inf);
+  return inf.hSubMenu;
+}
+
+
+#define MENUITEM_ABOUT 1
+#define MENUITEM_INFOBASE 10
+#define MENUITEM_VOLUMEBASE 100
+#define MENUITEM_VSYNC 120
+#define MENUITEM_ASPECTADJ 121
+#define MENUITEM_VOVERLAYS 122
+#define MENUITEM_VDDRAW 123
+#define MENUITEM_SOFTVOLMIX 124
+#define MENUITEM_ENABLESUBTITLES 125
+#define MENUITEM_SUBSIZEBASE 126 // 5 sizes
+
+#define MENUITEM_ZOOM50 112
+#define MENUITEM_ZOOM100 113
+#define MENUITEM_ZOOM200 114
+#define MENUITEM_ZOOM400 115
+#define MENUITEM_ZOOMFS 116
+
+#define MENUITEM_CLOSE 200
+
+#define MENUITEM_SUBSLANGBASE 300
+
+extern int g_audio_use_mixer;
+
+LRESULT my_wndcallback(void *token, HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+  if (token)
+  {
+    parms *parm=(parms*)token;
+#ifndef WNDMENU_NOPOSITIONSAVE
+    if (uMsg == WM_MOVE)
+    {
+      if (!parm->vidOut->is_fullscreen())
+      {
+        RECT r;
+        GetWindowRect(hwnd,&r);
+        _WriteConfigItemInt("xpos",r.left);
+        _WriteConfigItemInt("ypos",r.top);
+      }
+    }
+#endif
+    if(uMsg==WM_SETCURSOR && parm->vidOut->is_fullscreen()) {
+      SetCursor(NULL);
+      return TRUE;    
+    }
+
+    if (uMsg == WM_RBUTTONUP && !parm->vidOut->is_fullscreen())
+    {
+      int pos=0;
+      HMENU hMenu=CreatePopupMenu();
+
+#ifndef WNDMENU_NOABOUT
+      _InsertString(hMenu,pos++,WNDMENU_CAPTION,MENUITEM_ABOUT);
+      _InsertSep(hMenu,pos++);
+#endif
+#ifndef WNDMENU_NOINFO
+      if (parm->decode)
+      {
+        char buf[1024];
+        int subpos=0;
+        int tmpid=MENUITEM_INFOBASE;
+        HMENU sub=_InsertSub(hMenu,pos++,"Info");
+
+        { // title
+          char *v=parm->decode->getTitle();
+          if (v && *v)
+          {
+            char *tmp=(char*)malloc(strlen(v)+32);
+            wsprintf(tmp,"Title: %s",v);
+            char *p=tmp;
+            while (*p)
+            {
+              if (*p == '_') *p=' ';
+              p++;
+            }
+            _InsertString(sub,subpos++,tmp,tmpid++);
+            free(tmp);
+          }
+        }
+
+        
+        { // length
+          int lenms=parm->decode->getlen();
+          if (lenms != ~0)
+          {
+            wsprintf(buf,"Length: %d:%02d",lenms/60000,(lenms/1000)%60);
+            _InsertString(sub,subpos++,buf,tmpid++);
+          }
+        }
+
+
+        { // codecs
+          int a=(parm->decode->getBitrate()+500)/1000;
+          unsigned int a2=parm->decode->getFileSize();
+          if (a)
+          {
+            wsprintf(buf,"Bitrate: %dkbps",a);
+            if (a2 && a2 != ~0)
+              wsprintf(buf+strlen(buf)," (Total %u bytes)",a2);
+
+            _InsertString(sub,subpos++,buf,tmpid++);
+          }
+          else if (a2 && a2 != ~0)
+          {
+            wsprintf(buf,"Size: %u bytes",a2);
+            _InsertString(sub,subpos++,buf,tmpid++);
+          }
+
+          lstrcpy(buf,"Video: ");
+          char *p=buf+strlen(buf);
+          parm->decode->getVideoDesc(p);
+          if (*p) _InsertString(sub,subpos++,buf,tmpid++);
+
+          lstrcpy(buf,"Audio: ");
+          p=buf+strlen(buf);
+          parm->decode->getAudioDesc(p);
+          if (*p) _InsertString(sub,subpos++,buf,tmpid++);
+        }
+
+        {
+          const char *p=parm->decode->getServerHeader("Server");
+          if (p && *p)
+          {
+            lstrcpy(buf,"Server: ");
+            lstrcpyn(buf+strlen(buf),p,sizeof(buf)-strlen(buf)-2);
+            _InsertString(sub,subpos++,buf,tmpid++);
+          }
+        }
+      }
+#endif //WNDMENU_NOINFO
+#ifndef WNDMENU_NOVOLUME
+      if (parm->decode)
+      {
+        HMENU sub=_InsertSub(hMenu,pos++,"Volume");
+        int cv=(parm->decode->getvolume()*100)/255;
+        int x;
+        for (x=0;x<=10;x++)
+        {
+          char buf[64];
+          int a=100-x*10;
+          wsprintf(buf,"%d%%",a);
+          _InsertString(sub,x,buf,MENUITEM_VOLUMEBASE+x,cv >= a-5 && cv < a+5);
+        }
+      }
+#endif//WNDMENU_NOVOLUME
+#ifndef WNDMENU_NOOPTIONS
+      if (parm->vidOut)
+      {
+        HMENU sub=_InsertSub(hMenu,pos++,"Options");
+        int subpos=0;
+        _InsertString(sub,subpos++,"Synchronize video to refresh",MENUITEM_VSYNC,!!parm->vidOut->vid_vsync);
+        _InsertString(sub,subpos++,"Maintain video aspect ratio",MENUITEM_ASPECTADJ,!!parm->vidOut->vid_aspectadj);
+        _InsertString(sub,subpos++,"Allow video overlay",MENUITEM_VOVERLAYS,!!parm->vidOut->vid_overlays);
+        //_InsertString(sub,subpos++,"Allow DirectDraw acceleration",MENUITEM_VDDRAW,!!parm->vidOut->vid_ddraw);
+        _InsertString(sub,subpos++,"Use software volume mixing",MENUITEM_SOFTVOLMIX,!g_audio_use_mixer);
+      }
+#endif//WNDMENU_NOOPTIONS
+#if !defined(WNDMENU_NOZOOM) || !defined(WNDMENU_NOZOOMFS)
+      if (parm->decode && parm->vidOut)
+      {
+        HMENU sub=_InsertSub(hMenu,pos++,"Zoom");
+        int subpos=0;
+#ifndef WNDMENU_NOZOOM
+        int ow,oh;
+        int w=parm->decode->getWidth();
+        int h=parm->decode->getHeight();
+        parm->vidOut->getOutputSize(&ow,&oh);
+        _InsertString(sub,subpos++,"50%",MENUITEM_ZOOM50,ABS(w/2-ow)<4);
+        _InsertString(sub,subpos++,"100%",MENUITEM_ZOOM100,ABS(w-ow)<4);
+        _InsertString(sub,subpos++,"200%",MENUITEM_ZOOM200,ABS(w*2-ow)<4);
+        _InsertString(sub,subpos++,"400%",MENUITEM_ZOOM400,ABS(w/4-ow)<4);
+#ifndef WNDMENU_NOZOOMFS
+        _InsertSep(sub,subpos++);
+#endif
+#endif
+
+#ifndef WNDMENU_NOZOOMFS
+        _InsertString(sub,subpos++,"Fullscreen",MENUITEM_ZOOMFS,!!parm->vidOut->is_fullscreen());
+#endif//WNDMENU_NOZOOMFS
+      }
+#endif//WNDMENU_NOZOOM||WNDMENU_NOZOOMFS
+
+#ifndef WNDMENU_NOSUBTITLES
+      if(parm->decode)
+      {
+        HMENU sub=_InsertSub(hMenu,pos++,"Subtitles");
+        int subpos=0;
+        _InsertString(sub,subpos++,"Enabled",MENUITEM_ENABLESUBTITLES,parm->decode->subsEnabled());
+        _InsertSep(sub,subpos++);
+        HMENU sizesub=_InsertSub(sub,subpos++,"Font size");
+        int sizesubpos=0;
+        int fontsize=parm->decode->getSubsFontSize();
+        _InsertString(sizesub,sizesubpos++,"Largest",MENUITEM_SUBSIZEBASE,fontsize==20);
+        _InsertString(sizesub,sizesubpos++,"Larger",MENUITEM_SUBSIZEBASE+1,fontsize==10);
+        _InsertString(sizesub,sizesubpos++,"Medium",MENUITEM_SUBSIZEBASE+2,fontsize==0);
+        _InsertString(sizesub,sizesubpos++,"Smaller",MENUITEM_SUBSIZEBASE+3,fontsize==-4);
+        _InsertString(sizesub,sizesubpos++,"Smallest",MENUITEM_SUBSIZEBASE+4,fontsize==-8);
+        HMENU langsub=_InsertSub(sub,subpos++,"Language");
+        int langsubpos=0;
+        for(int i=0;;i++) {
+          const char *lang=parm->decode->getSubLanguage(i);
+          if(!lang) break;
+          _InsertString(langsub,langsubpos++,(char *)lang,MENUITEM_SUBSLANGBASE+i,i==parm->decode->getCurSubLanguage());
+        }
+      }
+#endif//WNDMENU_NOSUBTITLES
+
+#ifndef WNDMENU_NOCLOSE
+      _InsertSep(hMenu,pos++);
+      _InsertString(hMenu,pos++,"E&xit\tAlt+F4",MENUITEM_CLOSE);
+#endif//WNDMENU_NOCLOSE
+
+      POINT p;
+      GetCursorPos(&p);
+      int x=TrackPopupMenu(hMenu,TPM_RETURNCMD|TPM_RIGHTBUTTON|TPM_LEFTBUTTON|TPM_NONOTIFY,p.x,p.y,0,hwnd,NULL);
+      DestroyMenu(hMenu);
+      switch (x)
+      {
+#ifndef WNDMENU_NOABOUT
+        case MENUITEM_ABOUT:
+#ifdef _ABOUT_H_ // dont display the about box if do_about isn't there anyway
+          do_about(hwnd);
+#endif
+        break;
+#endif//WNDMENU_NOABOUT
+#ifndef WNDMENU_NOOPTIONS
+        case MENUITEM_VOVERLAYS:
+          _WriteConfigItemInt("overlays",parm->vidOut->vid_overlays=!parm->vidOut->vid_overlays);
+          PostMessage(hwnd,WM_USER+0x1,0,0); //renegotiate surface
+        break;
+        case MENUITEM_VDDRAW:
+          _WriteConfigItemInt("ddraw",parm->vidOut->vid_ddraw=!parm->vidOut->vid_ddraw);
+          PostMessage(hwnd,WM_USER+0x1,0,0); //renegotiate surface
+        break;
+        case MENUITEM_ASPECTADJ:
+          _WriteConfigItemInt("aspectadj",parm->vidOut->vid_aspectadj=!parm->vidOut->vid_aspectadj);
+          PostMessage(hwnd,WM_TIMER,1,0);
+        break;
+        case MENUITEM_VSYNC:
+          _WriteConfigItemInt("vsync",parm->vidOut->vid_vsync=!parm->vidOut->vid_vsync);
+        break;
+        case MENUITEM_SOFTVOLMIX:
+          _WriteConfigItemInt("use_mixer",g_audio_use_mixer=!g_audio_use_mixer);
+          parm->decode->setvolume(parm->decode->getvolume());
+        break;
+#endif//WNDMENU_NOOPTIONS
+
+#ifndef WNDMENU_NOZOOM
+        case MENUITEM_ZOOM50:
+        case MENUITEM_ZOOM100:
+        case MENUITEM_ZOOM200:
+        case MENUITEM_ZOOM400:
+          if (parm->vidOut->is_fullscreen()) parm->vidOut->remove_fullscreen();
+          {
+            int w=parm->decode->getWidth();
+            int h=parm->decode->getHeight();
+            if (x == MENUITEM_ZOOM50) { w/=2; h/=2; }
+            else if (x == MENUITEM_ZOOM200) { w*=2; h*=2; }
+            else if (x == MENUITEM_ZOOM400) { w*=4; h*=4; }
+            parm->vidOut->setOutputSize(w,h);
+
+          }
+        break;
+#endif//WNDMENU_NOZOOM
+#ifndef WNDMENU_NOZOOMFS
+        case MENUITEM_ZOOMFS:
+          if (parm->vidOut->is_fullscreen()) parm->vidOut->remove_fullscreen();
+          else parm->vidOut->fullscreen();
+        break;
+#endif//WNDMENU_NOZOOMFS
+#ifndef WNDMENU_NOCLOSE
+        case MENUITEM_CLOSE:
+          SendMessage(hwnd,WM_CLOSE,0,0);
+        break;
+#endif//WNDMENU_NOCLOSE
+#ifndef WNDMENU_NOSUBTITLES
+        case MENUITEM_ENABLESUBTITLES:
+          if(parm->decode) parm->decode->enableSubs(!parm->decode->subsEnabled());
+          _WriteConfigItemInt("subtitles",parm->decode->subsEnabled());
+        break;
+        case MENUITEM_SUBSIZEBASE:
+        case MENUITEM_SUBSIZEBASE+1:
+        case MENUITEM_SUBSIZEBASE+2:
+        case MENUITEM_SUBSIZEBASE+3:
+        case MENUITEM_SUBSIZEBASE+4:
+          if(parm->decode) {
+            int sizes[]={20,10,0,-4,-8};
+            int s=x-MENUITEM_SUBSIZEBASE;
+            parm->decode->setSubsFontSize(sizes[s]);
+            _WriteConfigItemInt("subtitles_size",parm->decode->getSubsFontSize());
+          }
+        break;
+#endif//WNDMENU_NOSUBTITLES
+        default:
+#ifndef WNDMENU_NOVOLUME
+          if (x >= MENUITEM_VOLUMEBASE && x <= MENUITEM_VOLUMEBASE+10)
+          {
+            int v=10-(x-MENUITEM_VOLUMEBASE);
+            parm->decode->setvolume((v*255)/10);
+            _WriteConfigItemInt("volume",parm->decode->getvolume());
+          }
+#endif
+          break;
+#ifndef WNDMENU_NOCLOSE
+    case WM_CLOSE:
+      DestroyWindow(hwnd);      
+    return 0;
+#endif
+      }
+#ifndef WNDMENU_NOSUBTITLES
+      if(x>=MENUITEM_SUBSLANGBASE && x<=MENUITEM_SUBSLANGBASE+64) {
+        parm->decode->setSubLanguage(x-MENUITEM_SUBSLANGBASE);
+      }
+#endif
+    }
+  }
+  return DefWindowProc(hwnd,uMsg,wParam,lParam);
+}
+
+
+#endif//_WNDMENU_H_
\ No newline at end of file
diff --git a/Src/nsv/svc_nsvFactory.cpp b/Src/nsv/svc_nsvFactory.cpp
new file mode 100644
index 00000000..dda7ce0e
--- /dev/null
+++ b/Src/nsv/svc_nsvFactory.cpp
@@ -0,0 +1 @@
+#include "svc_nsvFactory.h"
diff --git a/Src/nsv/svc_nsvFactory.h b/Src/nsv/svc_nsvFactory.h
new file mode 100644
index 00000000..ffc0ca66
--- /dev/null
+++ b/Src/nsv/svc_nsvFactory.h
@@ -0,0 +1,52 @@
+#ifndef NULLSOFT_NSV_SVC_NSVFACTORY_H
+#define NULLSOFT_NSV_SVC_NSVFACTORY_H
+
+#include <bfc/Dispatch.h>
+#include <bfc/platform/types.h>
+#include <api/service/services.h>
+class IAudioDecoder;
+class IVideoDecoder;
+class IAudioOutput;
+
+/*
+ **********************************************************************
+ *  Important Note!                                                   *
+ *                                                                    *
+ *                                                                    *
+ *  Objects created by this class are allocated using api_memmgr      *
+ *  You MUST call api_memmgr::Delete() to delete these objects.       *
+ *  Do not use the C++ delete operator                                *
+ *  as the memory was allocated with a different heap / malloc arena  *
+ *                                                                    *
+ **********************************************************************
+ */
+class svc_nsvFactory : public Dispatchable
+{
+protected:
+  svc_nsvFactory(){}
+  ~svc_nsvFactory(){}
+public:
+  virtual IAudioDecoder *CreateAudioDecoder(FOURCC format, IAudioOutput **output);
+  IVideoDecoder *CreateVideoDecoder(int w, int h, double framerate, unsigned int fmt, int *flip);
+  
+public:
+    DISPATCH_CODES
+  {
+    SVC_NSVFACTORY_CREATEAUDIODECODER=10,
+			 SVC_NSVFACTORY_CREATEVIDEODECODER=20,
+  };
+
+	static FOURCC getServiceType() { return WaSvc::NSVFACTORY; }
+};
+
+inline IAudioDecoder *svc_nsvFactory::CreateAudioDecoder(FOURCC format, IAudioOutput **output)
+{
+  return _call(SVC_NSVFACTORY_CREATEAUDIODECODER, (IAudioDecoder *)0, format, output);
+}
+
+inline IVideoDecoder *svc_nsvFactory::CreateVideoDecoder(int w, int h, double framerate, unsigned int fmt, int *flip)
+{
+	return _call(SVC_NSVFACTORY_CREATEVIDEODECODER, (IVideoDecoder *)0, w, h, framerate, fmt, flip);
+}
+
+#endif