winamp/Src/Plugins/Input/in_vorbis/http.cpp

#include "api__in_vorbis.h"
#include "../../..\Components\wac_network\wac_network_http_receiver_api.h"
#include "rf.h"
#include "main.h"
#include "../Winamp/wa_ipc.h"
#include <api/service/waservicefactory.h>
#include "../nu/AutoWide.h"
#include "../nu/AutoChar.h"
extern CfgInt cfg_fix0r,cfg_httpseek2,cfg_proxy_mode,cfg_prebuf1,cfg_prebuf2,cfg_fsave,cfg_http_bsize;

#define CANSEEK 

WORD *wdup(const char * src);//info.c

#define zeromem(x) memset(&x,0,sizeof(x))

class StreamSave
{
  private:
	ogg_sync_state   oy_src;
	ogg_stream_state os_src;
	ogg_stream_state os_dst;
	ogg_page         og_src;
	ogg_page         og_dst;
	ogg_packet       op;
	StringW tmp_fn;
	BOOL is_temp;
	BOOL got_streams,got_delta,use_fix0r;
	ogg_int64_t pcm_delta;
	int packets,serial;
	HANDLE hFile;
  public:

	StreamSave()
	{
		zeromem(oy_src);
		zeromem(os_src);
		zeromem(os_dst);
		zeromem(og_src);
		zeromem(og_dst);
		zeromem(op);
		got_streams=0;
		got_delta=0;
		pcm_delta=0;
		hFile=0;
		packets=0;
		serial=0;
		is_temp=1;

		tmp_fn=cfg_dumpdir;
		if (tmp_fn[tmp_fn.Length()-1]!='\\') tmp_fn.AddChar('\\');

		tmp_fn+=StringPrintfW(L"oggtemp%u.foo",GetTickCount64()&0xFFFF);

		hFile=CreateFileW(tmp_fn,GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_HIDDEN,0);
		if (hFile==INVALID_HANDLE_VALUE) hFile=0;
		else
		{
		ogg_sync_init(&oy_src);
		use_fix0r=cfg_fix0r;
		}
	};

	void Write(void * ptr,UINT siz)
	{
		if (!hFile) return;

		void * b=ogg_sync_buffer(&oy_src,siz);
		memcpy(b,ptr,siz);
		ogg_sync_wrote(&oy_src,siz);

		while(ogg_sync_pageout(&oy_src,&og_src)>0)
		{
			if (!got_streams)
			{
				serial=ogg_page_serialno(&og_src);
				ogg_stream_init(&os_src,serial);
				ogg_stream_init(&os_dst,serial);
				got_streams=1;
				packets=0;
				got_delta=0;
			}
			else if (serial!=ogg_page_serialno(&og_src))
			{
				if (got_streams)
				{
					/*while(ogg_stream_flush(&os_dst,&og_dst))
					{
						write_page(dst,&og_dst,&wb);
					}*/

					ogg_stream_clear(&os_src);
					ogg_stream_clear(&os_dst);
				}
				serial=ogg_page_serialno(&og_src);
				ogg_stream_init(&os_src,serial);
				ogg_stream_init(&os_dst,serial);

				packets=0;
				got_delta=0;
			}

			ogg_stream_pagein(&os_src,&og_src);
			while(ogg_stream_packetout(&os_src,&op)>0)
			{
				if (use_fix0r && !got_delta && packets>2 && op.granulepos>=0) //hack to fix saved streams
				{
					got_delta=1;
					if (op.granulepos>4096*(packets-2)) pcm_delta=op.granulepos;
				}
				if (got_delta)
				{
					if (op.granulepos>=pcm_delta) op.granulepos-=pcm_delta;
					else if (op.granulepos>0) op.granulepos=0;
				}
				ogg_stream_packetin(&os_dst,&op);
				packets++;
			}

			while((packets==3 ? ogg_stream_flush(&os_dst,&og_dst) :  ogg_stream_pageout(&os_dst,&og_dst))>0)
			{
				DWORD bw = 0;
				WriteFile(hFile,og_dst.header,og_dst.header_len,&bw,0);
				bw = 0; WriteFile(hFile,og_dst.body,og_dst.body_len,&bw,0);
			}
		}
	}

	void FixName(VorbisFile * vf,const char * streamname)
	{
	    if (!hFile) return;
		CloseHandle(hFile);
		StringW fn(cfg_dumpdir);

		if (fn[fn.Length()-1]!='\\') fn.AddChar('\\');

		UINT n=fn.Length();
		fn+=(wchar_t *)AutoWide(vf->get_meta("TITLE", 0), CP_UTF8);
		UINT m=fn.Length();

		while(n<m)
		{
			char * b="/\\:*?\"<>|";
			while(b && *b)
			{
				if (fn[n]==*b) {fn.SetChar(n,'_');break;}
				b++;
			}
			n++;
		};
		fn.AddStringA(".ogg");
		if (!MoveFileW(tmp_fn,fn))
		{
			DeleteFileW(fn);
			MoveFileW(tmp_fn,fn);
		}
		SetFileAttributesW(fn,FILE_ATTRIBUTE_NORMAL);
		hFile=CreateFileW(fn,GENERIC_WRITE,0,0,OPEN_EXISTING,0,0);

		if (hFile==INVALID_HANDLE_VALUE) {hFile=0;}
		else SetFilePointer(hFile,0,0,FILE_END);
		is_temp=0;
	}

	~StreamSave()
	{
		if (hFile)
		{
			/*if (got_streams)
			{
				while(ogg_stream_flush(&os_dst,&og_dst))
				{
					write_page(dst,&og_dst,&wb);
				}
			}*/

			ogg_stream_clear(&os_src);
			ogg_stream_clear(&os_dst);

			SetFilePointer(hFile,0,0,FILE_CURRENT);
			CloseHandle(hFile);
			if (is_temp) DeleteFileW(tmp_fn);
		}
		ogg_sync_clear(&oy_src);
	}
};

static const char * do_proxy(const char * url)
{
	switch(cfg_proxy_mode)
	{
	default:
		return 0;
	case 1:
		{
			const char * p=strstr(url,"://");
			if (!p) p=url;
			while(p && *p && *p!=':' && *p!='/') p++;
			if (p && *p==':')
			{
				if (atoi(p+1)!=80) return 0;
			}
		}
	case 2:
		{
			char *x = (char *)SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GET_PROXY_STRING);
			if (x == (char *)1 || !x || !*x)
				return 0;
			return x;
		}
	}
}

class VorbisFile_HTTP : public VorbisFile
{
  protected:
	api_httpreceiver *get;
	UINT bsize;
	uint64_t len;
	UINT pos; 
	UINT seekpos;
	BOOL can_seek;
	StreamSave * saver;
	virtual void Idle();
	virtual int f_seek(__int64 offset,int whence);
	virtual size_t f_read(UINT siz,void * ptr);
	virtual UINT f_tell();
	virtual UINT FileSize() {return len;}
	bool is_live;

  public:
	virtual int GetType() {return TYPE_HTTP;}
	virtual bool IsLive() {return is_live;}
	bool http_init();

	void do_prebuf() {VorbisFile::do_prebuf();fillbuf(bsize * cfg_prebuf1 / 100,0);}

	VorbisFile_HTTP(UINT s, const wchar_t *u,bool is_info, bool hasauth) : VorbisFile(u,is_info), usedauth(hasauth)
	{
		get=0;
		can_seek=0;
		len=pos=seekpos=0;
		bsize=s;
		saver=0;
		m_needs_auth=0;
		lpinfo[0]=0;
		force_lpinfo[0]=0;
		is_live = false;
		memset(dlg_realm, 0, sizeof(dlg_realm));
	}

	~VorbisFile_HTTP()
	{
		if (get)
		{
			waServiceFactory *sf = mod.service->service_getServiceByGuid(httpreceiverGUID);
			if (sf)  
				sf->releaseInterface(get);
			get=0;
		}
		if (saver) delete saver;
	}

	void fillbuf(UINT max,bool shutup);

	size_t _http_read(char* ptr,size_t total);
	int reconnect(UINT ofs);
	virtual void post_init()
	{
		if (saver) saver->FixName(this,get->getheader("ice-name"));
	}

	static BOOL CALLBACK httpDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
	int m_needs_auth;
	char dlg_realm[256];
	char lpinfo[256];
	char force_lpinfo[256];
	bool usedauth;
};

int VorbisFile_HTTP::reconnect(UINT ofs)
{
	//	get.reset_headers();
	get->addheader("User-Agent: WinampOGG/5.24(MPEG stream compatible)");
	get->addheader("Accept:*/*");
	if (ofs>0) get->addheader(StringPrintf("Range: bytes=%u-",ofs));
	get->connect(AutoChar(url));

	Status(WASABI_API_LNGSTRINGW(IDS_CONNECTING));

	int st=get->run();
	if (st<0)
	{
		return 1;
	}
	return 0;
}

void VorbisFile_HTTP::fillbuf(UINT max,bool shutup)
{
	if (len>0 && pos+max>len) max=len-pos;
	while(!Aborting() && !abort_prebuf)	//stop prebuffering if we wanna seek
	{
		if (!shutup)
		{
			Status(StringPrintfW(WASABI_API_LNGSTRINGW(IDS_PREBUFFERING), get->bytes_available()*100/bsize));
		}
		if (get->run()) break;
		if (Aborting() || abort_prebuf || get->bytes_available()>=(int)max) break;
		Sleep(2);
	}
	if (!shutup)
	{
		Status(0);
	}
}

size_t VorbisFile_HTTP::_http_read(char* ptr,size_t total)
{
#ifdef CANSEEK
	if (seekpos!=-1)
	{
		UINT sp=seekpos;
		seekpos=-1;
		if (sp!=pos)
		{
			if (sp>pos && sp<=pos+get->bytes_available())
			{
				get->get_bytes(0,sp-pos);
			}
			else
			{
				if (reconnect(sp))
				{
				return 0;//oh well...
				}
			}
			pos=sp;
		}
	}
#endif
	UINT wr=0;
	while(!Aborting() && wr<total)
	{
		int st=get->run();
		int d=get->get_bytes(ptr,(int)total-wr);
		if (st && !d) break;
		wr+=d;
		ptr+=d;
		pos+=d;
		if ((len>0 && pos>=len) || wr>=total || Aborting()) break;
		if (use_prebuf) fillbuf(bsize * cfg_prebuf2 / 100,0);
		else Sleep(1);
	}
	return wr;
}

void VorbisFile_HTTP::Idle()
{
	get->run();
	Sleep(1);
	get->run();
	Sleep(1);
}

size_t VorbisFile_HTTP::f_read(UINT siz,void* ptr)
{
	if (Aborting()) return 0;//fixme
	int i=(int)_http_read((char*)ptr,siz);
	if (i>0 && saver) saver->Write(ptr,i);
	return i;
}

int VorbisFile_HTTP::f_seek(ogg_int64_t offset,int whence)
{
#ifdef CANSEEK
	if (can_seek)
	{
		switch(whence)
		{
		case FILE_BEGIN:
			seekpos=(int)offset;
			break;
		case FILE_END:
			seekpos=len+(int)offset;
			break;
		case FILE_CURRENT:
			seekpos=pos+(int)offset;
			break;
		}
		if (seekpos>len) seekpos=len;
		return 0;
	}
	else 
#endif
    return -1;
}

UINT VorbisFile_HTTP::f_tell()
{
#ifdef CANSEEK
	if (can_seek)
	{
		if (seekpos!=-1) return seekpos;
		else return pos;
	}
	else
#endif
    return -1;
}

HWND GetDialogBoxParent()
{
	HWND parent = (HWND)SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GETDIALOGBOXPARENT);
	if (!parent || parent == (HWND)1)
		return mod.hMainWindow;
	return parent;
}

bool VorbisFile_HTTP::http_init()
{
	if (mod.service)
	{
		waServiceFactory *sf = mod.service->service_getServiceByGuid(httpreceiverGUID);
		if (sf)  get = (api_httpreceiver *)sf->getInterface();
	}
	if (!get) return false;
	get->open(API_DNS_AUTODNS, bsize, do_proxy(AutoChar(url)));

	if (reconnect(0))
	{
		return 0;
	}

#ifdef CANSEEK
	//	if (cfg_httpseek)
	{
		//need to get http headers first
		while(!memcmp(get->getallheaders(),"\0\0",2))
		{
			if (get->run()<0 || Aborting())
			{
				int reply = get->getreplycode();
				if ( reply == 401 )
				{
					api_connection *mcon=get->GetConnection();
					if ( mcon && mcon->GetReceiveBytesAvailable())
					{
						char p[1024]="";
						while ( mcon->GetReceiveBytesAvailable() )
						{
							char b[2048]="";
							mcon->ReceiveLine(b,2048);
							if ( *b )
							{
								char *t= strstr(b,"WWW-Authenticate:");
								if ( t && *t )
								{
									char *y = strstr(t,"\"");
									if ( y && *y )
									{
										y++;
										if ( *y )
										{
											char *u = strstr(y,"\"");
											if ( u && *u )
											{
												*u = 0;
												wsprintfA(p,"%s",y);
											}
										}
									}
								}
							}
						}

						if ( *p )  // found our realm
						{
							if (!force_lpinfo[0]) GetPrivateProfileStringA("HTTP-AUTH",p,"",force_lpinfo,sizeof(force_lpinfo),INI_FILE);
							if (!force_lpinfo[0] || lpinfo[0] || usedauth )
							{
								lstrcpynA(dlg_realm,p,sizeof(dlg_realm));
								if (!WASABI_API_DIALOGBOXPARAM(IDD_HTTPAUTH, GetDialogBoxParent(), httpDlgProc, (LPARAM)this))
								{
									force_lpinfo[0]=0;
								}
								else
								{
									WritePrivateProfileStringA("HTTP-AUTH",p,force_lpinfo,INI_FILE);
								}
							}
							Status(WASABI_API_LNGSTRINGW(IDS_AUTH_REQUIRED));
							m_needs_auth=1;
						}
					}
				}
				return 0;
			}
			//hg->get.wait(10);
			Sleep(1);
		}
		len=get->content_length();
		const char* poo=get->getheader("icy-name");
		if (poo) stream_title=poo;
		if (cfg_httpseek2 && len) can_seek=1;
		is_live=(len<=0);
	}
#endif

	//if (hg->len==0 || hg->len==-1) hg->can_seek=0;	
	seekpos=-1;

	if (cfg_fsave && !can_seek)
	{
		saver=new StreamSave;
	}
	return 1;
}

VorbisFile * VorbisFile::Create_HTTP(const char * url,bool is_info)
{
	VorbisFile_HTTP * r=new VorbisFile_HTTP(cfg_http_bsize,AutoWide(url),is_info, false);
	if (r)
	{
		if (!r->http_init())
		{
			int trys=0;
			while ( r && r->m_needs_auth && trys++ < 2)
			{
				const char *p=strstr(url,"://");
				if (p && *p)
				{
					p += 3;
					if (p && *p)
					{
						char lurl[4096] = {0};
						wsprintfA(lurl, "http://%s@%s", r->force_lpinfo, p);
						delete r;
						r = new VorbisFile_HTTP(cfg_http_bsize,AutoWide(lurl),is_info, true);
						if (r && r->http_init())
						{
							return r;
						}
					}
				}
			}
			delete r;
			r=0;
		}
	}
	return r;
}

BOOL CALLBACK VorbisFile_HTTP::httpDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
{
	VorbisFile_HTTP *_this;
	switch (uMsg)
	{
	case WM_INITDIALOG:
#ifdef WIN64
		SetWindowLong(hwndDlg, GWLP_USERDATA, (LONG)lParam);
		_this = (VorbisFile_HTTP*)(GetWindowLong(hwndDlg, GWLP_USERDATA));
#else
		SetWindowLong(hwndDlg, GWL_USERDATA, (LONG)lParam);
		_this = (VorbisFile_HTTP*)GetWindowLong(hwndDlg, GWL_USERDATA);
#endif
		if (_this->force_lpinfo[0])
			SetDlgItemTextA(hwndDlg,IDC_EDITAUTH,_this->force_lpinfo);
		else SetDlgItemTextA(hwndDlg,IDC_EDITAUTH,_this->lpinfo);
			SetDlgItemTextA(hwndDlg,IDC_REALM,_this->dlg_realm);
		return 1;

	case WM_COMMAND:
#ifdef WIN64
		_this = (VorbisFile_HTTP*)GetWindowLong(hwndDlg, GWLP_USERDATA);
#else
		_this = (VorbisFile_HTTP*)GetWindowLong(hwndDlg, GWL_USERDATA);
#endif
		if (LOWORD(wParam) == IDOKAUTH)
		{
			char *p;
			GetDlgItemTextA(hwndDlg,IDC_EDITAUTH,_this->force_lpinfo,sizeof(_this->force_lpinfo));
			p = strstr(_this->force_lpinfo,"\r");
			if ( p && *p ) *p=0;
			p = strstr(_this->force_lpinfo,"\n");
			if ( p && *p ) *p=0;
			EndDialog(hwndDlg,1);
		}
		else if (LOWORD(wParam) == IDCANCELAUTH)
		{
			EndDialog(hwndDlg,0);
		}
		break;
	}
	return 0;
}