diff options
Diffstat (limited to 'Src/Plugins/Input/in_vorbis')
47 files changed, 9027 insertions, 0 deletions
diff --git a/Src/Plugins/Input/in_vorbis/DlgBase.cpp b/Src/Plugins/Input/in_vorbis/DlgBase.cpp new file mode 100644 index 00000000..43b0f771 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/DlgBase.cpp @@ -0,0 +1,67 @@ +#include "DlgBase.h" + +void DlgBase::MakeComboEdit(UINT id, DWORD s) +{ + HWND w = GetDlgItem(wnd, id); + RECT r; + GetChildRect(id, r); + DestroyWindow(w); + CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", 0, WS_CHILD | s, r.left - 1, r.top - 1, r.right - r.left, r.bottom - r.top, wnd, (HMENU)id, 0, 0); +} + +void DlgBase::GetChildRect(UINT id, RECT& child) +{ + RECT r_parent, r_child; + GetWindowRect(wnd, &r_parent); + GetWindowRect(GetDlgItem(wnd, id), &r_child); + int dx = r_parent.left; + int dy = r_parent.top; + if (!(GetWindowLong(wnd, GWL_STYLE)&WS_CHILD)) + { + dy += GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYDLGFRAME); + dx += GetSystemMetrics(SM_CXDLGFRAME); + } + child.left = r_child.left - dx; + child.right = r_child.right - dx; + child.top = r_child.top - dy; + child.bottom = r_child.bottom - dy; +} + +void DlgBase::do_sizing(UINT wp, RECT * r) + { + UINT dx, dy; + dx = r->right - r->left; + dy = r->bottom - r->top; + if (dx < min_size_x_w) + { + switch (wp) + { + case WMSZ_BOTTOMLEFT: + case WMSZ_LEFT: + case WMSZ_TOPLEFT: + r->left = r->right - min_size_x_w; + break; + case WMSZ_BOTTOMRIGHT: + case WMSZ_RIGHT: + case WMSZ_TOPRIGHT: + r->right = r->left + min_size_x_w; + break; + } + } + if (dy < min_size_y_w) + { + switch (wp) + { + case WMSZ_BOTTOMLEFT: + case WMSZ_BOTTOM: + case WMSZ_BOTTOMRIGHT: + r->bottom = r->top + min_size_y_w; + break; + case WMSZ_TOPLEFT: + case WMSZ_TOP: + case WMSZ_TOPRIGHT: + r->top = r->bottom - min_size_y_w; + break; + } + } + }
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/DlgBase.h b/Src/Plugins/Input/in_vorbis/DlgBase.h new file mode 100644 index 00000000..a194e836 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/DlgBase.h @@ -0,0 +1,118 @@ +#include <windows.h> +#include "main.h" + +static void SetWindowRect(HWND w, RECT * r) +{ + SetWindowPos(w, 0, r->left, r->top, r->right - r->left, r->bottom - r->top, SWP_NOZORDER | SWP_NOCOPYBITS); +} + +class DlgBase +{ + public: + BOOL isDialogMessage(MSG * m) + { + return wnd ? IsDialogMessage(wnd, m) : 0; + } +protected: + void endDialog(int x) + { + EndDialog(wnd, x); + } + + void _do_size_x(RECT * r, UINT id, UINT wx, UINT min_x) + { + RECT r1 = {r->left, r->top, wx - min_x + r->right, r->bottom}; + SetWindowRect(GetDlgItem(wnd, id), &r1); + } + + void _do_size_xy(RECT * r, UINT id, UINT wx, UINT wy, UINT min_x, UINT min_y) + { + RECT r1 = {r->left, r->top, wx - min_x + r->right, wy - min_y + r->bottom}; + SetWindowRect(GetDlgItem(wnd, id), &r1); + } + + void _do_align_x_size_y(RECT * r, UINT id, UINT wx, UINT wy, UINT min_x, UINT min_y) + { + RECT r1 = {wx - min_x + r->left, r->top, wx - min_x + r->right, wy - min_y + r->bottom}; + SetWindowRect(GetDlgItem(wnd, id), &r1); + } + + void _do_align_x(RECT * r, UINT id, UINT wx, UINT min_x) + { + RECT r1 = {wx - min_x + r->left, r->top, wx - min_x + r->right, r->bottom}; + SetWindowRect(GetDlgItem(wnd, id), &r1); + } + + void _do_align_xy(RECT * r, UINT id, UINT wx, UINT wy, UINT min_x, UINT min_y) + { + RECT r1 = {wx - min_x + r->left, wy - min_y + r->top, wx - min_x + r->right, wy - min_y + r->bottom}; + SetWindowRect(GetDlgItem(wnd, id), &r1); + } + +#define do_size_x(id,r) _do_size_x(r,id,sx,min_size_x) +#define do_size_xy(id,r) _do_size_xy(r,id,sx,sy,min_size_x,min_size_y) +#define do_align_x_size_y(id,r) _do_align_x_size_y(r,id,sx,sy,min_size_x,min_size_y) +#define do_align_xy(id,r) _do_align_xy(r,id,sx,sy,min_size_x,min_size_y) +#define do_align_x(id,r) _do_align_x(r,id,sx,min_size_x) + + HWND wnd; + UINT min_size_x, min_size_y; + UINT min_size_x_w, min_size_y_w; + + void do_sizing(UINT wp, RECT * r); + void MakeComboEdit(UINT id, DWORD s); + void GetChildRect(UINT id, RECT& child); + + virtual BOOL DlgProc(UINT msg, WPARAM wp, LPARAM lp) { return 0;}; + static BOOL CALLBACK TheDialogProc(HWND wnd, UINT msg, WPARAM wp, LPARAM lp) + { + DlgBase * p; + if (msg == WM_INITDIALOG) + { + p = (DlgBase*)lp; + SetWindowLong(wnd, DWL_USER, lp); + p->wnd = wnd; + RECT r; + GetClientRect(wnd, &r); + p->min_size_x = r.right; + p->min_size_y = r.bottom; + GetWindowRect(wnd, &r); + p->min_size_x_w = r.right - r.left; + p->min_size_y_w = r.bottom - r.top; + } + else p = (DlgBase*)GetWindowLong(wnd, DWL_USER); + BOOL rv = 0; + if (p) + { + rv = p->DlgProc(msg, wp, lp); + if (msg == WM_DESTROY) + { + p->wnd = 0; + SetWindowLong(wnd, DWL_USER, 0); + } + } + return rv; + } + HWND myCreateDialog(UINT id, HWND parent) + { + return CreateDialogParamT(hIns, (char*)id, parent, TheDialogProc, (long)this); + } + virtual void myProcessMessage(MSG * msg) + { + if (!IsDialogMessage(wnd, msg)) + { + TranslateMessage(msg); + DispatchMessage(msg); + } + } + + int myDialogBox(UINT id, HWND parent) + { + return DialogBoxParamT(hIns, (char*)id, parent, TheDialogProc, (long)this); + } + DlgBase() { + wnd = 0; + min_size_x = min_size_y = min_size_x_w = min_size_y_w = 0; + } + virtual ~DlgBase() {} +}; diff --git a/Src/Plugins/Input/in_vorbis/ExtendedRead.cpp b/Src/Plugins/Input/in_vorbis/ExtendedRead.cpp new file mode 100644 index 00000000..c89f829d --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/ExtendedRead.cpp @@ -0,0 +1,65 @@ +#include "main.h" +#include "decoder.h" + +extern "C" +{ + //returns handle!=0 if successful, 0 if error + //size will return the final nb of bytes written to the output, -1 if unknown + __declspec( dllexport ) intptr_t winampGetExtendedRead_openW(const wchar_t *fn, int *size, int *bps, int *nch, int *srate) { + VorbisFile * f = VorbisFile::Create(fn,false); + if(f) { + if(!*bps) *bps=16; // FUCKO HAX + Decoder * d = new Decoder(); + d->Init(f, *bps, *nch, false, false); + *nch = (int)d->nch; + *srate = (int)d->sr; + *bps = (int)d->bps; + *size = (int)(f->Length() * (double)((*nch) * (*srate) * (*bps/8))); + return (intptr_t)d; + } + return 0; + } + + __declspec( dllexport ) intptr_t winampGetExtendedRead_openW_float(const wchar_t *fn, int *size, int *bps, int *nch, int *srate) { + VorbisFile * f = VorbisFile::Create(fn,false); + if(f) { + Decoder * d = new Decoder(); + d->Init(f, *bps, *nch, true, false); + *nch = (int)d->nch; + *srate = (int)d->sr; + *bps = (int)d->bps; + *size = (int)(f->Length() * (double)((*nch) * (*srate) * (*bps/8))); + return (intptr_t)d; + } + return 0; + } + + //returns nb of bytes read. -1 if read error (like CD ejected). if (ret<len), EOF is assumed + __declspec( dllexport ) intptr_t winampGetExtendedRead_getData(intptr_t handle, char *dest, size_t len, int *killswitch) { + Decoder * d = (Decoder *)handle; + size_t used = 0; + for(;;) { + used += (UINT)d->Read((UINT)(len - used),dest + used); + if(used >= len) break; + if(!d->DoFrame()) break; + if(*killswitch) break; + if (used) + return used; + } + return used; + } + + // return nonzero on success, zero on failure. + __declspec( dllexport ) int winampGetExtendedRead_setTime(intptr_t handle, int millisecs) { + Decoder * d = (Decoder *)handle; + d->Flush(); + return !d->Seek(((double)millisecs) / 1000.0); + } + + __declspec( dllexport ) void winampGetExtendedRead_close(intptr_t handle) { + Decoder * d = (Decoder *)handle; + d->Flush(); + delete d->file; + delete d; + } +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/about.cpp b/Src/Plugins/Input/in_vorbis/about.cpp new file mode 100644 index 00000000..32409519 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/about.cpp @@ -0,0 +1,264 @@ +#include "main.h" +#include "api__in_vorbis.h" +#include "resource.h" +#include <strsafe.h> + +/*static UINT xiphframes_ids[12]={IDB_BITMAP1,IDB_BITMAP2,IDB_BITMAP3,IDB_BITMAP4,IDB_BITMAP5,IDB_BITMAP6,IDB_BITMAP7,IDB_BITMAP8,IDB_BITMAP9,IDB_BITMAP10,IDB_BITMAP11,IDB_BITMAP12}; +static HBITMAP xiphframes[12];*/ + +static UINT xiphframes_ids[12]={IDB_PNG1,IDB_PNG2,IDB_PNG3,IDB_PNG4,IDB_PNG5,IDB_PNG6,IDB_PNG7,IDB_PNG8,IDB_PNG9,IDB_PNG10,IDB_PNG11,IDB_PNG12}; +static ARGB32 *xiphframes[12] = {0}; +static HBITMAP xiphframesBmp[12] = {0}; + +static void slap(HWND wnd,int v) +{ + long hi=GetWindowLong(wnd,4); + if (v) hi+=v*1000; + else hi=0; + SetWindowLong(wnd,4,hi); +} + +static CfgInt cfg_rpm("rpm",0); + +static int visible_rpm,visible_max_rpm; +static char show_rpm=0; +static DWORD last_visible_rpm; + +ARGB32 * loadImg(const void * data, int len, int *w, int *h, bool ldata=false) +{ + FOURCC imgload = svc_imageLoader::getServiceType(); + int n = (int)mod.service->service_getNumServices(imgload); + for(int i=0; i<n; i++) + { + waServiceFactory *sf = mod.service->service_enumService(imgload,i); + if(sf) + { + svc_imageLoader * l = (svc_imageLoader*)sf->getInterface(); + if(l) + { + if(l->testData(data,len)) + { + ARGB32* ret; + if(ldata) ret = l->loadImageData(data,len,w,h); + else ret = l->loadImage(data,len,w,h); + sf->releaseInterface(l); + return ret; + } + sf->releaseInterface(l); + } + } + } + return NULL; +} + +ARGB32 * loadRrc(int id, wchar_t * sec, int *w, int *h, bool data=false) +{ + DWORD size=0; + HGLOBAL resourceHandle = WASABI_API_LOADRESFROMFILEW(sec, MAKEINTRESOURCEW(id), &size); + if(resourceHandle) + { + ARGB32* ret = loadImg(resourceHandle,size,w,h,data); + UnlockResource(resourceHandle); + return ret; + } + return NULL; +} + +static LRESULT WINAPI XiphProc(HWND wnd,UINT msg,WPARAM wp,LPARAM lp) +{ + switch(msg) + { + case WM_CREATE: + SetWindowLong(wnd,8,last_visible_rpm=GetTickCount()); + SetTimer(wnd,666,10,0); + visible_rpm=-1; + visible_max_rpm=-1; + show_rpm=0; + break; + case WM_TIMER: + if (wp==666) + { + long low=GetWindowLong(wnd,0); + long hi=GetWindowLong(wnd,4); + + long org=low&~0xFFFF; + + int rpm=MulDiv(abs(hi),1000*60,12*0x10000); + + DWORD t=GetTickCount(); + DWORD ot=(DWORD)SetWindowLong(wnd,8,t); + bool redraw=0; + + if (rpm>25) show_rpm=1; + if (cfg_rpm<rpm) cfg_rpm=rpm; + + if (show_rpm && (t&~0x3F)!=(ot&~0x3F)) + { + wchar_t foo[128] = {0}; + if (visible_rpm<rpm || (visible_rpm>rpm && (t-last_visible_rpm)>333)) + { + last_visible_rpm=t; + visible_rpm=rpm; + StringCchPrintfW(foo,128,WASABI_API_LNGSTRINGW(IDS_GAME_SPEED),rpm); + SetDlgItemTextW(GetParent(wnd),IDC_RPM,foo); + } + if (visible_max_rpm!=cfg_rpm) + { + visible_max_rpm=cfg_rpm; + StringCchPrintfW(foo,128,WASABI_API_LNGSTRINGW(IDS_BEST_RPM),(int)cfg_rpm); + SetDlgItemTextW(GetParent(wnd),IDC_RPM2,foo); + } + } + + low+=hi*(t-ot); + while(low<0) low+=12*0x10000; + while(low>=12*0x10000) low-=12*0x10000; + + { + int z=hi>>6; + if (z) hi-=z; + else if (hi>0) hi--; + else if (hi<0) hi++; + } + + SetWindowLong(wnd,0,low); + SetWindowLong(wnd,4,hi); + if (redraw || (low&~0xFFFF)!=org) + { + RedrawWindow(wnd,0,0,RDW_INVALIDATE); + } + KillTimer(wnd,666); + SetTimer(wnd,666,10,0); + } + break; + case WM_LBUTTONDOWN: + slap(wnd,-1); + break; + case WM_RBUTTONDOWN: + slap(wnd,1); + break; + case WM_MBUTTONDOWN: + slap(wnd,0); + break; + case WM_PAINT: + { + int i=(GetWindowLong(wnd,0))>>16; + HDC dc = CreateCompatibleDC(0); + + if (!xiphframesBmp[i]) + { + int cur_w = 0, cur_h = 0; + xiphframes[i] = loadRrc(xiphframes_ids[i], L"PNG", &cur_w, &cur_h, true); + + BITMAPINFO bmi = {0}; + bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + bmi.bmiHeader.biWidth = cur_w; + bmi.bmiHeader.biHeight = -cur_h; + bmi.bmiHeader.biPlanes = 1; + bmi.bmiHeader.biBitCount = 32; + bmi.bmiHeader.biCompression = BI_RGB; + void *bits = 0; + if(xiphframesBmp[i]) DeleteObject(xiphframesBmp[i]); + xiphframesBmp[i] = CreateDIBSection(dc, &bmi, DIB_RGB_COLORS, &bits, NULL, 0); + memcpy(bits, xiphframes[i], cur_w * cur_h * 4); + } + + if (xiphframesBmp[i]) + { + HGDIOBJ foo = SelectObject(dc, xiphframesBmp[i]); + HDC wdc = GetDC(wnd); + RECT r = {0}; + GetClientRect(wnd, &r); + FillRect(wdc, &r, GetSysColorBrush(COLOR_3DFACE)); + + BLENDFUNCTION blendFn = {0}; + blendFn.BlendOp = AC_SRC_OVER; + blendFn.SourceConstantAlpha = 255; + blendFn.AlphaFormat = AC_SRC_ALPHA; + AlphaBlend(wdc, 2, 2, r.right - 2, r.bottom - 2, dc, 0, 0, 63, 63, blendFn); + + ReleaseDC(wnd, wdc); + SelectObject(dc, foo); + } + DeleteDC(dc); + } + break; + case WM_DESTROY: + { + for (int i = 0; i < ARRAYSIZE(xiphframes_ids); i++) + { + if(xiphframesBmp[i]) DeleteObject(xiphframesBmp[i]); xiphframesBmp[i] = 0; + if(xiphframes[i] && WASABI_API_MEMMGR) WASABI_API_MEMMGR->sysFree((void *)xiphframes[i]); xiphframes[i] = 0; + } + KillTimer(wnd,666); + break; + } + }; + return DefWindowProc(wnd,msg,wp,lp); +} + +static BOOL CALLBACK AboutProc(HWND wnd,UINT msg,WPARAM wp,LPARAM lp) +{ + switch(msg) + { + case WM_INITDIALOG: + { + wchar_t tmp[1024] = {0}, tmp2[1024] = {0}, *t1 = tmp, *t2 = tmp2, text[1024] = {0}; + SetWindowTextW(wnd,WASABI_API_LNGSTRINGW_BUF(IDS_NULLSOFT_VORBIS_DECODER_OLD,text,1024)); + StringCchPrintfW(tmp,1024,WASABI_API_LNGSTRINGW(IDS_ABOUT_TEXT),mod.description,__DATE__); + // due to quirks with the more common resource editors, is easier to just store the string + // internally only with \n and post-process to be \r\n (as here) so it will appear correctly + // on new lines as is wanted (silly multiline edit controls) + while(t1 && *t1 && (t2 - tmp2 < 1024)) + { + if(*t1 == L'\n') + { + *t2 = L'\r'; + t2 = CharNextW(t2); + } + *t2 = *t1; + t1 = CharNextW(t1); + t2 = CharNextW(t2); + } + + SetDlgItemTextW(wnd,IDC_ABOUT_TEXT,tmp2); + // fixes the incorrect selection of the text on dialog opening + PostMessage(GetDlgItem(wnd,IDC_ABOUT_TEXT),EM_SETSEL,-1,0); + return 1; + } + case WM_COMMAND: + if (wp==IDOK || wp==IDCANCEL) + { + do_cfg(1); + EndDialog(wnd,0); + } + break; + } + return 0; +} + +void About(HWND hwndParent) +{ + static char got_xiph; + if (!got_xiph) + { + WNDCLASS wc= + { + 0, + XiphProc, + 0, + 12, + WASABI_API_LNG_HINST, + 0, + LoadCursor(0,IDC_ARROW), + 0, + 0, + L"XIPH_CLASS", + }; + + RegisterClassW(&wc); + got_xiph=1; + } + + WASABI_API_DIALOGBOXW(IDD_ABOUT,hwndParent,AboutProc); +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/api__in_vorbis.h b/Src/Plugins/Input/in_vorbis/api__in_vorbis.h new file mode 100644 index 00000000..5f89683e --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/api__in_vorbis.h @@ -0,0 +1,21 @@ +#ifndef NULLSOFT_API_H +#define NULLSOFT_API_H + +#include "../Agave/Config/api_config.h" +#include "../Agave/Language/api_language.h" + +#include <api/application/api_application.h> +extern api_application *applicationApi; +#define WASABI_API_APP applicationApi + +#include <api/service/svcs/svc_imgload.h> + +#include <api/service/api_service.h> + +#include <api/service/waServiceFactory.h> + +#include <api/memmgr/api_memmgr.h> +extern api_memmgr *memmgrApi; +#define WASABI_API_MEMMGR memmgrApi + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/c_string.cpp b/Src/Plugins/Input/in_vorbis/c_string.cpp new file mode 100644 index 00000000..4310a0dd --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/c_string.cpp @@ -0,0 +1,96 @@ +#define STRICT +#include <windows.h> +#include <malloc.h> +#include <stdio.h> +#include "c_string.h" +#include "../nu/ns_wc.h" + +extern BOOL is_nt; + +template<class myChar> +void string_base<myChar>::makespace(UINT s) +{ + if (size<s) + { + int oldSize = size; + do size<<=1; while(size<s); + myChar *newPtr = (myChar*)realloc(ptr,size*sizeof(myChar)); + if (!newPtr) + { + newPtr = (myChar*)malloc(size*sizeof(myChar)); + if (newPtr) + { + memcpy(newPtr, ptr, oldSize*sizeof(myChar)); + free(ptr); + ptr = newPtr; + } + else return ; + } + else ptr = newPtr; + } +} + +void String::s_GetWindowText(HWND w) +{ + Reset(); + int len=GetWindowTextLengthA(w)+1; + GetWindowTextA(w,StringTempA(*this,len),len); +} + +void StringW::s_GetWindowText(HWND w) +{ + Reset(); + int len=GetWindowTextLengthW(w)+1; + GetWindowTextW(w,StringTempW(*this,len),len); +} + +void String::SetStringW(const WCHAR * c) +{ + UINT len=(lstrlenW(c)+1)*2; + WideCharToMultiByteSZ(CP_ACP,0,c,-1,StringTempA(*this,len),len,0,0); +} + +void StringW::SetStringA(const char * c) +{ + UINT len=(UINT)strlen(c)+1; + MultiByteToWideCharSZ(CP_ACP,0,c,-1,StringTempW(*this,len),len); +} + +void String::AddStringW(const WCHAR * c) +{ + AddString(String(c)); +} + +void StringW::AddStringA(const char * c) +{ + AddString(StringW(c)); +} + +void String::s_SetWindowText(HWND w) +{ + SetWindowTextA(w,*this); +} + +void StringW::s_SetWindowText(HWND w) +{ + SetWindowTextW(w,*this); +} + + +StringPrintf::StringPrintf(const char * fmt,...) +{ + va_list list; + va_start(list,fmt); + vsprintf(StringTempA(*this,1024),fmt,list); + va_end(list); +} + +StringPrintfW::StringPrintfW(const WCHAR * fmt,...) +{ + va_list list; + va_start(list,fmt); + vswprintf(StringTempW(*this,1024),1024,fmt,list); + va_end(list); +} + +String::String(const StringW & z) {AddStringW(z);}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/c_string.h b/Src/Plugins/Input/in_vorbis/c_string.h new file mode 100644 index 00000000..9773c078 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/c_string.h @@ -0,0 +1,156 @@ +#pragma once +template <class myChar> +class string_base +{ +private: + myChar * ptr; + UINT size,used; + void makespace(UINT s); + static UINT mylen(const myChar * p) {UINT r=0;while(p[r]) r++;return r;} +public: + void AddChar(myChar c) + { + makespace(used+2); + ptr[used++]=c; + ptr[used]=0; + } + string_base() + { + used=0; + size=128; + ptr=(myChar*)malloc(size*sizeof(myChar)); + ptr[0]=0; + } + + ~string_base() { if (ptr) free(ptr);} + + operator const myChar*() const {return ptr;} + + const myChar & operator*() const {return *ptr;} + + UINT Length() const {return used;} + + void AddString(const myChar * c) + { + UINT d=mylen(c); + makespace(used+d+1); + memcpy(ptr+used,c,sizeof(myChar)*d); + used+=d; + ptr[used]=0; + } + + void Reset() {Truncate(0);} + void Truncate(UINT x) {if (used>x) {used=x;ptr[x]=0;}} + + void SetString(const myChar * s) {Reset();AddString(s);} + + myChar * BufferStart(UINT n) + { + makespace(n+1); + memset(ptr,0,size); + return ptr; + } + + inline void BufferDone() {used=mylen(ptr);} + + void SetChar(UINT offset,myChar c)//hack for some ghey routines + { + if (!c) Truncate(offset); + else if (offset<used) ptr[offset]=c; + } +}; + +template<class myChar> +class StringTemp +{ +private: + string_base<myChar> * parent; + myChar * data; +public: + StringTemp(string_base<myChar> & s,UINT siz) {parent=&s;data=s.BufferStart(siz);} + ~StringTemp() {parent->BufferDone();} + operator myChar* () {return data;} +}; + +#define StringTempW StringTemp<WCHAR> +#define StringTempA StringTemp<char> + +class StringW; + +class String : public string_base<char> +{ +public: + String() {} + String(HWND w) {s_GetWindowText(w);} + String(const char* z) {SetString(z);} + String(const WCHAR* z) {SetStringW(z);} + String(const String& z) {SetString(z);} + String(const StringW& z); + void AddStringW(const WCHAR * c); + void SetStringW(const WCHAR * c); + void s_GetWindowText(HWND w); + void s_SetWindowText(HWND w); + void operator=(const char * s) {SetString(s);} + void operator+=(const char * s) {AddString(s);} + void operator=(String & s) {SetString(s);} + void operator+=(String & s) {AddString(s);} + inline void s_GetDlgItemText(HWND w,UINT id) {s_GetWindowText(GetDlgItem(w,id));} + inline void s_SetDlgItemText(HWND w,UINT id) {s_SetWindowText(GetDlgItem(w,id));} +}; + +class StringW : public string_base<WCHAR> +{ +public: + StringW() {} + StringW(HWND w) {s_GetWindowText(w);} + StringW(const WCHAR * z) {SetString(z);} + void AddStringA(const char * c); + void SetStringA(const char * c); + StringW(const char * z) {SetStringA(z);} + StringW(const StringW & z) {SetString(z);} + StringW(const String & z) {SetStringA(z);} + void s_GetWindowText(HWND w); + void s_SetWindowText(HWND w); + void operator=(const WCHAR * s) {SetString(s);} + void operator+=(const WCHAR * s) { if (s) AddString(s);} + void operator=(StringW & s) {SetString(s);} + void operator+=(StringW & s) {AddString(s);} + inline void s_GetDlgItemText(HWND w,UINT id) {s_GetWindowText(GetDlgItem(w,id));} + inline void s_SetDlgItemText(HWND w,UINT id) {s_SetWindowText(GetDlgItem(w,id));} + bool reg_read(const char *name); + void reg_write(const char *name); +}; + + +class StringPrintf : public String +{ +public: + StringPrintf(const char * fmt,...); +}; + +class StringPrintfW : public StringW +{ +public: + StringPrintfW(const WCHAR * fmt,...); +}; + +template<class myChar> +class StringF2T : public string_base<myChar> +{ +public: + StringF2T(const myChar * fn) + { + const myChar * ptr=fn,*dot=0,*src=fn; + while(ptr && *ptr) + { + if (*ptr=='\\' || *ptr=='/' || *ptr==':') src=ptr+1; + else if (*ptr=='.') dot=ptr; + ptr++; + } + + while(src && *src && (!dot || src<dot)) AddChar(*(src++)); + } +}; + +#define StringF2T_A StringF2T<char> +#define StringF2T_W StringF2T<WCHAR>
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/chainedstream_parse.cpp b/Src/Plugins/Input/in_vorbis/chainedstream_parse.cpp new file mode 100644 index 00000000..35ed0198 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/chainedstream_parse.cpp @@ -0,0 +1,82 @@ +#include <windows.h> +#include <stdlib.h> +#include <stdio.h> + +#include <ogg/ogg.h> +#include <vorbis/vorbisfile.h> + +static size_t callback_fread(void *ptr, size_t size, size_t nmemb, HANDLE hFile) +{ + DWORD bw = 0; + ReadFile(hFile,ptr,(DWORD)(size*nmemb),&bw,0); + return bw/size; +} + +static size_t callback_write(void * ptr, size_t size, size_t nmemb, HANDLE hFile) +{ + DWORD bw = 0; + WriteFile(hFile,ptr,(DWORD)(size*nmemb),&bw,0); + return bw/size; +} + +static int callback_fseek(HANDLE hFile, __int64 offset, int whence) +{ + __int64 temp = offset; + SetFilePointer(hFile,*(DWORD*)&temp,((long*)&temp+1),whence); + return 0; +} + +static int callback_fclose(HANDLE f) +{ + return 0; +} + +static __int64 callback_ftell(HANDLE hFile) +{ + __int64 ret=0; + *(DWORD*)&ret = SetFilePointer(hFile,0,((long*)&ret+1),FILE_CURRENT); + return ret; +} + +static void* callbacks[4]= +{ + callback_fread,callback_fseek,callback_fclose,callback_ftell +}; + +namespace ogg_helper +{ + int num_get_tracks(HANDLE hFile/*track_indexer::callback * out,reader * r*/) + { + SetFilePointer(hFile,0,0,FILE_BEGIN); + OggVorbis_File l_vf; + memset(&l_vf,0,sizeof(l_vf)); + if (ov_open_callbacks(hFile,&l_vf,0,0,*(ov_callbacks*)callbacks)) + { + return 0; + } + int rv = l_vf.links; + ov_clear(&l_vf); + return rv; + } + + int query_chained_stream_offset(HANDLE hFile,int idx,__int64 * out_beginning,__int64 * out_end) + { + SetFilePointer(hFile,0,0,FILE_BEGIN); + OggVorbis_File l_vf; + memset(&l_vf,0,sizeof(l_vf)); + if (ov_open_callbacks(hFile,&l_vf,0,0,*(ov_callbacks*)callbacks)) + { + return 0; + } + int retval = 0; + if (idx>=0 && idx<l_vf.links) + { + retval = 1; + *out_beginning = l_vf.offsets[idx]; + *out_end = l_vf.offsets[idx+1]; + } + + ov_clear(&l_vf); + return retval; + } +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/config.cpp b/Src/Plugins/Input/in_vorbis/config.cpp new file mode 100644 index 00000000..fc3d6afd --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/config.cpp @@ -0,0 +1,335 @@ +#include "main.h" +#include "api__in_vorbis.h" +#include "../nu/ns_wc.h" +#include <commctrl.h> +#include <shlobj.h> +#include "../winamp/wa_ipc.h" +#include "../nu/AutoChar.h" +#include <strsafe.h> + +int mc6_dm_names_ids[]={IDS_LEAVE_AS_IS,IDS_REMAP_6_CHANNELS,IDS_DOWNMIX_TO_4_CHANNELS,IDS_DOWNMIX_TO_2_CHANNELS_DS,IDS_DOWNMIX_TO_2_CHANNELS_DS2,IDS_DOWNMIX_TO_MONO}; +int mc6_map_names_id[]={IDS_CORRECT_FL_FC_FR_BL_BR_LFE,IDS_BROKEN_FL_FR_FC_BL_BR_LFE}; +int32_t priority_tab[7]={THREAD_PRIORITY_IDLE,THREAD_PRIORITY_LOWEST,THREAD_PRIORITY_BELOW_NORMAL,THREAD_PRIORITY_NORMAL,THREAD_PRIORITY_ABOVE_NORMAL,THREAD_PRIORITY_HIGHEST,THREAD_PRIORITY_TIME_CRITICAL}; + +char* defaultDumpDir() +{ + static char dumpdir[MAX_PATH] = {0}; + if(FAILED(SHGetFolderPathA(NULL, CSIDL_MYMUSIC, NULL, SHGFP_TYPE_CURRENT, dumpdir))) + { + if(FAILED(SHGetFolderPathA(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, dumpdir))) + { + lstrcpynA(dumpdir, "C:\\", MAX_PATH); + } + } + return dumpdir; +} + +CfgString + cfg_ssave_format("ssave_format","%filename%"), + cfg_dumpdir("dumpdir",defaultDumpDir()); + +CfgInt + cfg_http_bsize("http_bsize",0x10000), + cfg_fsave("fsave",0), + cfg_abr("abr",0), + cfg_proxy_mode("proxy_mode",2), + cfg_prebuf1("prebuf1",50), + cfg_prebuf2("prebuf2",75), + cfg_httpseek2("httpseek2",0), + cfg_fix0r("fix0r",1), + cfg_mc6_dm("mc6_dm",0), + cfg_mc6_map("_mc6_map",0), + cfg_remember_infosize("remember_infosize",1), + cfg_fullbuf("fullbuf",0), + cfg_cur_tab("cur_tab",0); + +static int old_preamp; +CfgFont cfg_font("font"); +static LOGFONT cfg_font_edit; + +BOOL CALLBACK browseEnumProc(HWND hwnd, LPARAM lParam) +{ + char cl[32] = {0}; + GetClassNameA(hwnd, cl, ARRAYSIZE(cl)); + if (!lstrcmpiA(cl, WC_TREEVIEWA)) + { + PostMessage(hwnd, TVM_ENSUREVISIBLE, 0, (LPARAM)TreeView_GetSelection(hwnd)); + return FALSE; + } + + return TRUE; +} + +static int CALLBACK browzaproc(HWND hwnd, UINT msg, LPARAM lp, LPARAM dat) +{ + if (msg == BFFM_INITIALIZED) + { + SendMessageW(hwnd, BFFM_SETSELECTIONW, 1, (LPARAM)dat); + + // this is not nice but it fixes the selection not working correctly on all OSes + EnumChildWindows(hwnd, browseEnumProc, 0); + } + return 0; +} + +static void d_browza(HWND wnd,HWND bt,wchar_t* tx) +{ + IMalloc* pMalloc=0; + + SHGetMalloc(&pMalloc); + if (!pMalloc) return; + + wchar_t dir[MAX_PATH] = {0}; + GetWindowTextW(bt,dir,MAX_PATH); + BROWSEINFOW bi= + { + wnd, + 0, + 0, + tx, + BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE, + browzaproc, + (LPARAM)dir, + 0 + }; + ITEMIDLIST* li=SHBrowseForFolderW(&bi); + if (li) + { + SHGetPathFromIDListW(li,dir); + SetWindowTextW(bt,dir); + pMalloc->Free(li); + } + + pMalloc->Release(); +} + +static BOOL CALLBACK CfgProc1(HWND wnd,UINT msg,WPARAM wp,LPARAM lp) +{ + switch(msg) + { + case WM_INITDIALOG: + { + wchar_t temp[128] = {0}, cfg_dialog_name[128] = {0}; + StringCchPrintfW(cfg_dialog_name,128,WASABI_API_LNGSTRINGW(IDS_TITLE_PREFERENCES), + WASABI_API_LNGSTRINGW_BUF(IDS_NULLSOFT_VORBIS_DECODER_OLD, temp, 128)); + SetWindowTextW(wnd,cfg_dialog_name); + + SendDlgItemMessage(wnd,IDC_FULLBUF,BM_SETCHECK,cfg_fullbuf,0); + + UINT n; + HWND w=GetDlgItem(wnd,IDC_MC6_DM); + for(n=0;n<sizeof(mc6_dm_names_ids)/sizeof(mc6_dm_names_ids[0]);n++) + { + SendMessageW(w,CB_ADDSTRING,0,(LPARAM)WASABI_API_LNGSTRINGW(mc6_dm_names_ids[n])); + } + SendMessage(w,CB_SETCURSEL,cfg_mc6_dm,0); + + w=GetDlgItem(wnd,IDC_MC6_MAP); + for(n=0;n<sizeof(mc6_map_names_id)/sizeof(mc6_map_names_id[0]);n++) + { + SendMessageW(w,CB_ADDSTRING,0,(LPARAM)WASABI_API_LNGSTRINGW(mc6_map_names_id[n])); + } + SendMessage(w,CB_SETCURSEL,cfg_mc6_map,0); + + SendDlgItemMessage(wnd,IDC_AVG_BR,BM_SETCHECK,cfg_abr,0); + + SetDlgItemInt(wnd,IDC_HTTP_BSIZE,cfg_http_bsize>>10,0); + if (cfg_fsave) SendDlgItemMessage(wnd,IDC_FSAVE,BM_SETCHECK,1,0); + if (cfg_fix0r) SendDlgItemMessage(wnd,IDC_FIX0R,BM_SETCHECK,1,0); + cfg_dumpdir.s_SetDlgItemText(wnd,IDC_STREAM_SAVE); + w=GetDlgItem(wnd,IDC_PROXY); + SendMessageW(w,CB_ADDSTRING,0,(LPARAM)WASABI_API_LNGSTRINGW(IDS_NEVER)); + SendMessageW(w,CB_ADDSTRING,0,(LPARAM)WASABI_API_LNGSTRINGW(IDS_PORT_80_ONLY)); + SendMessageW(w,CB_ADDSTRING,0,(LPARAM)WASABI_API_LNGSTRINGW(IDS_ALWAYS)); + SendMessage(w,CB_SETCURSEL,cfg_proxy_mode,0); + + w=GetDlgItem(wnd,IDC_SLIDER1); + SendMessage(w,TBM_SETRANGE,0,MAKELONG(1,100)); + SendMessage(w,TBM_SETPOS,1,cfg_prebuf1); + w=GetDlgItem(wnd,IDC_SLIDER2); + SendMessage(w,TBM_SETRANGE,0,MAKELONG(1,100)); + SendMessage(w,TBM_SETPOS,1,cfg_prebuf2); + + cfg_ssave_format.s_SetDlgItemText(wnd,IDC_SSAVE_FMT); + SendMessage(wnd,WM_COMMAND,MAKEWPARAM(IDC_FSAVE,BN_CLICKED),(LPARAM)GetDlgItem(wnd,IDC_FSAVE)); + } + return 1; + + case WM_COMMAND: + switch(LOWORD(wp)) + { + case IDC_STREAM_SAVE: + d_browza(wnd,(HWND)lp,WASABI_API_LNGSTRINGW(IDS_SELECT_OUTPUT_DIRECTORY)); + break; + + case IDC_SSAVE_FMT_DEF: + SetDlgItemText(wnd,IDC_SSAVE_FMT,L"%filename%"); + break; + + case IDC_FSAVE: + { + int checked = IsDlgButtonChecked(wnd,IDC_FSAVE); + EnableWindow(GetDlgItem(wnd,IDC_STREAM_SAVE),checked); + EnableWindow(GetDlgItem(wnd,IDC_SSAVE_FMT),checked); + EnableWindow(GetDlgItem(wnd,IDC_SSAVE_FMT_DEF),checked); + } + break; + + case IDOK: + case IDCANCEL: + { + if (LOWORD(wp) == IDOK) + { + cfg_fullbuf=(int)SendDlgItemMessage(wnd,IDC_FULLBUF,BM_GETCHECK,0,0); + + cfg_mc6_dm=(int)SendDlgItemMessage(wnd,IDC_MC6_DM,CB_GETCURSEL,0,0); + cfg_mc6_map=(int)SendDlgItemMessage(wnd,IDC_MC6_MAP,CB_GETCURSEL,0,0); + + cfg_abr=(int)SendDlgItemMessage(wnd,IDC_AVG_BR,BM_GETCHECK,0,0); + + cfg_dumpdir.s_GetDlgItemText(wnd,IDC_STREAM_SAVE); + cfg_http_bsize=GetDlgItemInt(wnd,IDC_HTTP_BSIZE,0,0)<<10; + cfg_fsave=(int)SendDlgItemMessage(wnd,IDC_FSAVE,BM_GETCHECK,0,0); + cfg_fix0r=(int)SendDlgItemMessage(wnd,IDC_FIX0R,BM_GETCHECK,0,0); + cfg_proxy_mode=(int)SendDlgItemMessage(wnd,IDC_PROXY,CB_GETCURSEL,0,0); + cfg_prebuf1=(int)SendDlgItemMessage(wnd,IDC_SLIDER1,TBM_GETPOS,0,0); + cfg_prebuf2=(int)SendDlgItemMessage(wnd,IDC_SLIDER2,TBM_GETPOS,0,0); + cfg_ssave_format.s_GetDlgItemText(wnd,IDC_SSAVE_FMT); + } + do_cfg(1); + EndDialog(wnd,(LOWORD(wp) == IDOK)); + } + break; + } + break; + } + + const int controls[] = + { + IDC_SLIDER1, + IDC_SLIDER2, + }; + if (FALSE != WASABI_API_APP->DirectMouseWheel_ProcessDialogMessage(wnd, msg, wp, lp, controls, ARRAYSIZE(controls))) + { + return TRUE; + } + + return 0; +} + +extern HANDLE hThread;//hack + +void Config(HWND p) +{ + if (WASABI_API_DIALOGBOXPARAMW(IDD_CONFIG,p,CfgProc1,0)) + { + if (hThread) PostMessage(mod.hMainWindow,WM_USER,0,243); + } +} + +int CfgVar::read_int(const char *inifile, const char *section,const char * name,int def) +{ + return GetPrivateProfileIntA(section, name, def, inifile); +} + +void CfgVar::write_int(const char *inifile, const char *section, const char * name,int val) +{ + char temp[32] = {0}; + StringCchPrintfA(temp, 32, "%d", val); + WritePrivateProfileStringA(section, name, temp, inifile); +} + +void CfgVar::write_struct(const char *inifile, const char *section, const char * name, void * ptr,UINT size) +{ + WritePrivateProfileStructA("in_vorbis", name, ptr, size, INI_FILE); +} + +bool CfgVar::read_struct(const char *inifile, const char *section, const char * name,void * ptr,UINT size) +{ + return !!GetPrivateProfileStructA("in_vorbis", name, ptr, size, INI_FILE); +} + +void do_cfg(int s) +{ + #define CFG_VERSION 0x10204 + + if (!s) + { + if (CfgVar::read_int(INI_FILE, "in_vorbis", "version",0)==CFG_VERSION) + CfgVar::ReadConfig(); + } + else + { + CfgVar::WriteConfig(); + CfgVar::write_int(INI_FILE, "in_vorbis", "version",CFG_VERSION); + } +} + +CfgVar * CfgVar::list=0; + +void CfgVar::ReadConfig() +{ + CfgVar * p=list; + while(p) + { + p->Read(p->name); + p=p->next; + } +} + +void CfgVar::WriteConfig() +{ + CfgVar * p=list; + while(p) + { + p->Write(p->name); + p=p->next; + } +} + +bool StringW::reg_read(const char * name) +{ + char utf8_data[2048] = {0}; + wchar_t utf16_data[2048] = {0}; + GetPrivateProfileStringA("in_vorbis", name, "@default@", utf8_data, 2048, INI_FILE); + if (!strcmp("@default@", utf8_data)) + return false; + + MultiByteToWideCharSZ(CP_UTF8, 0, utf8_data, -1, utf16_data, 2048); + SetString(utf16_data); + + return true; +} + +void StringW::reg_write(const char * name) +{ + WritePrivateProfileStringA("in_vorbis", name, AutoChar((const WCHAR *)*this, CP_UTF8), INI_FILE); +} + +void CfgString::Read(const char * name) +{ + reg_read(name); +} + +void CfgString::Write(const char * name) +{ + StringW temp; + if (temp.reg_read(name)) + { + if (wcscmp(temp,*this)) reg_write(name); + } + else + { + if (wcscmp(def,*this)) reg_write(name); + } +} + +void CfgInt::Write(const char * name) +{ + if (read_int(INI_FILE, "in_vorbis", name,def)!=value) write_int(INI_FILE, "in_vorbis",name,value); +} + +void CfgInt::Read(const char * name) +{ + value=read_int(INI_FILE, "in_vorbis", name,def); +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/core_api.h b/Src/Plugins/Input/in_vorbis/core_api.h new file mode 100644 index 00000000..07d48b5b --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/core_api.h @@ -0,0 +1,567 @@ + +/* Winamp 3 Player core api v0.1 +** (c)2000 nullsoft jcf/ct/dk +** Notes: +** Keep in mind that this header file is subject to change prior to the +** release of Winamp 3. The ability to configure plug-ins has yet to be +** added and is the first and foremost concern of the engineering team. +*/ + +#ifndef __CORE_API_H +#define __CORE_API_H +/* +// Visual C 6 makes big unaligned dlls. the following will correct it +#ifndef _DEBUG +// release optimizations +// /Og (global optimizations), /Os (favor small code), /Oy (no frame pointers) +#pragma optimize("gsy",on) +#pragma comment(linker,"/RELEASE") +// set the 512-byte alignment +#pragma comment(linker,"/opt:nowin98") +#endif +*/ +// Use Assert in your code to catch errors that shouldn't happen, when compiled in release mode, they are #defined out +#ifndef ASSERT +#ifdef _DEBUG +#define ASSERT(x) if (!(x)) MessageBox(NULL,"ASSERT FAILED: " #x,"ASSERT FAILED in " __FILE__ ,MB_OK|MB_ICONSTOP); +#else +#define ASSERT(x) +#endif +#endif + + + +/* CLASS DESCRIPTIONS */ + +/* WReader +** File reader module class, ie. opens and reads files, streams +*/ +class WReader; + +/* WInputInfo +** Class that returns information (length, title, metadata) about a specified file +*/ +class WInputInfo; + +/* WInfo_callback +** Player's interface that provides Winamp 3 core functions to your WInputInfo classes +*/ +class WInfo_callback; + +/* WInputSource +** Input Source manager base class, ie. decodes mp3's, wavs +*/ +class WInputSource; + +/* WOutputFilter +** Abstract base class for any Output Filter plug-in, ie. changes pitch, converts format, outputs to speakers +*/ +class WOutputFilter; + +/* WPlayer_callback +** Player's interface that provides Winamp 3 core functions to your Input Sources and Output Filter plug-ins +** (Getting a reader for opening a file, sending stuff about what's going on to the Winamp 3 core) +*/ +class WPlayer_callback; + + + + +class WPlayer_callback +{ + public: + /* GetReader + ** Allows your Input Source and Output Filter plugins to request a reader from Winamp, + ** so you don't have to worry about opening files or streams + */ + virtual WReader *GetReader(char *url)=0; + + + /* The 3 following functions allows your Input Source and Output Filter plugins to send error/warning/status + ** messages back to the Winamp 3 core + */ + + /* Error + ** playback should stop (soundcard driver error, etc) + */ + virtual void Error(char *reason)=0; + + /* Warning + ** warning (something recoverable, like file not found, etc) + */ + virtual void Warning(char *warning)=0; + + /* Status + ** status update (nothing really wrong) + */ + virtual void Status(char *status)=0; + + + + + /* TitleChange + ** should be called if the current file titlename changes during the decoding + */ + virtual void TitleChange(char *new_title)=0; + + /* InfoChange + ** should be called if the infos about the current file changes during the decoding + */ + virtual void InfoChange(char *new_info_str, int new_length)=0; + + /* UrlChange + ** should be called if the current file associated URL changes during the decoding + */ + virtual void UrlChange(char *new_url)=0; +}; + + + + +class WInfo_callback +{ + public: + /* GetReader + ** Allows your WInfo classes to request a reader from Winamp + ** so you don't have to worry about opening files or streams + */ + virtual WReader *GetReader(char *url)=0; +}; + + + + +class WInputInfo +{ + public: + /* WInputInfo + ** WInputInfo constructor + */ + WInputInfo(){ }; + + /* m_info + ** Filled by Winamp. Pointer to WInputInfo callback function + */ + WInfo_callback *m_info; + + /* Open + ** Called by Winamp to request informations about a specified media (file, url, etc...) + ** returns 0 if succesful, 1 if not + ** + ** You must open, get all information and close the specified file here and store + ** the useful information into member elements for quick access by other functions + */ + virtual int Open(char *url) { return 1; } + + /* GetTitle + ** Called by Winamp to get the decoded title about the file opened + ** i.e. id3 title name, etc... + */ + virtual void GetTitle(char *buf, int maxlen) { if (maxlen>0) buf[0]=0; }; + + /* GetInfoString + ** Called by Winamp to get extra informations about the file opened + ** i.e. "160kbps stereo 44Khz" for MP3 files,"4 channels" for MOD files,etc... + */ + virtual void GetInfoString(char *buf, int maxlen) { if (maxlen>0) buf[0]=0; }; + + /* GetLength + ** Called by Winamp to retrieves media type length in milliseconds + ** returns -1 if length is undefined/infinite + */ + virtual int GetLength(void) { return -1; }; + + /* GetMetaData + ** Fetches metadata by attribute name (Artist, Album, Bitrate, etc...) + ** attribute names are non case-sensitive. + ** returns size of data + */ + virtual int GetMetaData(char *name, char *data, int data_len) { if (data&&data_len>0) *data=0; return 0; } + + /* ~WInputInfo + ** WInputInfo virtual destructor + */ + //virtual ~WInputInfo() { }; + virtual void Release(int)=0; +}; + + + + + + + + +/* WINAMP Output Filter NOTIFY MESSAGES +** Messages returned to notify Output Filter plug-ins of events +*/ + +typedef enum { + + /* WOFNM_FILETITLECHANGE + ** Sent when the song changes + ** param1=new filename song + ** param2=new title song + */ + WOFNM_FILETITLECHANGE=1024, + + /* WOFNM_ENDOFDECODE + ** Sent when decoding ends + */ + WOFNM_ENDOFDECODE, + +} WOutputFilterNotifyMsg; + + + + +class WOutputFilter +{ + protected: + /* WOutputFilter + ** WOutputFilter constructor + */ + WOutputFilter() { m_next=NULL; }; + + public: + /* m_player + ** Filled by Winamp. Pointer to Winamp 3 core player interface + */ + WPlayer_callback *m_player; + + /* m_next + ** Internally used by Winamp. Pointer to next activated Output Filter + */ + WOutputFilter *m_next; + + /* ~WOutputFilter + ** WOutputFilter destructor + */ + //virtual ~WOutputFilter() { }; + virtual void Release(int)=0; + + /* GetDescription + ** Retrieves your plug-in's text description + */ + virtual char *GetDescription() { return "Unknown"; }; + + /* ProcessSamples + ** Render data as it receives it + ** sampledata: Data to process + ** bytes: number of bytes to process + ** bps: Bits per sample (8 or 16) + ** nch: Number of channels (1 or 2) + ** srate: Sample rate in Hz + ** killswitch: Will be set to 1 by winamp if stop if requested. Poll the pointed value very often to + ** make sure Winamp doesn't hang + ** + ** Returns the number of processed bytes or -1 if unable to open the device or an error occured. + ** + ** You have to open your device (ie. Directsound) the first time this function is called. + */ + virtual int ProcessSamples(char *sampledata, int bytes, int *bps, int *nch, int *srate, bool *killswitch) { return bytes; } + + /* FlushSamples + ** Flushes output buffers so that all is written + */ + virtual void FlushSamples(bool *killswitch) { }; + + /* Restart + ** Called by Winamp after a seek + */ + virtual void Restart(void) { } + + /* GetLatency + ** Returns < 0 for a final output latency, > 0 for an additive + */ + virtual int GetLatency(void) { return 0; } + + /* Pause + ** Suspends output + */ + virtual void Pause(int pause) { } + + /* ShutDown + ** Completely stops output + ** + ** Close your device here (not in destructor) + */ + virtual void ShutDown(void) { } + + /* SetVolume + ** Sets the volume (0 to 255) + ** return 1 if volume successfully modified + */ + virtual int SetVolume(int volume) { return 0; } + + /* SetPan + ** Sets Left-Right sound balance (-127 to 127) + ** return 1 if pan successfully modified + */ + virtual int SetPan(int pan) { return 0; } + + /* Notify + ** Called by Winamp to notify what's going on + */ + virtual void Notify(WOutputFilterNotifyMsg msg, int data1, int data2) { } + +}; + + + + +class WInputSource +{ + + protected: + /* WInputSource + ** WInputSource constructor + */ + WInputSource(){ }; + + + public: + /* m_player + ** Filled by Winamp. Pointer to Winamp 3 core interface + */ + WPlayer_callback *m_player; + + /* GetDescription + ** Retrieves your plug-in's text description + */ + virtual char *GetDescription() { return "Unknown"; }; + + /* UsesOutputFilters + ** Returns whether or not the Output Filter pipeline can be used + */ + virtual int UsesOutputFilters(void) { return 1; } + + /* Open + ** Used to open and prepare input media type + */ + virtual int Open(char *url, bool *killswitch)=0; + + /* GetSamples + ** This function must fill bps, nch and srate. + ** Here, you have to fill the sample_buffer with decoded data. Be sure to fill it with the specified + ** size (bytes). Use an internal buffer, etc ... + ** + ** sample_buffer: buffer to put decoded data into + ** bytes: size of the sample_buffer + ** bps: Bits par sample (8 or 16) + ** nch: Number of channels (1 or 2) + ** srate: Sample rate in Hz + ** killswitch: Will be set to 1 by winamp if stop if requested. Poll the pointed value very often to + ** make sure Winamp doesn't hang + */ + virtual int GetSamples(char *sample_buffer, int bytes, int *bps, int *nch, int *srate, bool *killswitch)=0; + + /* SetVolume + ** Sets the volume (0 to 255) + ** Return 1 if volume has been set + */ + virtual int SetVolume(int volume) { return 0; }; + + /* SetPan + ** Sets Left-Right sound balance (-127 to 127) + ** return 1 if pan successfully modified + */ + virtual int SetPan(int pan) { return 0; }; + + /* SetPosition + ** Sets position in ms. returns 0 on success, 1 if seek impossible + */ + virtual int SetPosition(int)=0; + + /* Pause + ** Suspends input + */ + virtual void Pause(int pause) { }; + + /* GetPosition + ** Retrieve position in milliseconds + */ + virtual int GetPosition(void) { return 0; } + + /* GetTitle + ** Called by Winamp to get the decoded title about the file opened + ** i.e. stream name, id3 title name, etc... + */ + virtual void GetTitle(char *buf, int maxlen) { if(maxlen>0) buf[0]=0; }; + + /* GetInfoString + ** Called by Winamp to get extra informations about the file openend + ** i.e. "32kbps 44khz", etc... + */ + virtual void GetInfoString(char *buf, int maxlen) { if(maxlen>0) buf[0]=0; }; + + /* GetLength + ** Called by Winamp to retrieves media type length in milliseconds + ** returns -1 if length is undefined/infinite + */ + virtual int GetLength(void) { return -1; } + + /* ~WInputSource + ** ~WInputSource virtual destructor + */ + //virtual ~WInputSource() { }; + virtual void Release(int)=0; +}; + + + + +class WReader +{ + protected: + + /* WReader + ** WReader constructor + */ + WReader() { } + + public: + + /* m_player + ** Filled by Winamp. Pointer to Winamp 3 core interface + */ + WPlayer_callback *m_player; + + /* GetDescription + ** Retrieves your plug-in's text description + */ + virtual char *GetDescription() { return "Unknown"; }; + + /* Open + ** Used to open a file, return 0 on success + */ + virtual int Open(char *url, bool *killswitch)=0; + + /* Read + ** Returns number of BYTES read (if < length then eof or killswitch) + */ + virtual int Read(char *buffer, int length, bool *killswitch)=0; + + /* GetLength + ** Returns length of the entire file in BYTES, return -1 on unknown/infinite (as for a stream) + */ + virtual int GetLength(void)=0; + + /* CanSeek + ** Returns 1 if you can skip ahead in the file, 0 if not + */ + virtual int CanSeek(void)=0; + + /* Seek + ** Jump to a certain absolute position + */ + virtual int Seek(int position, bool *killswitch)=0; + + /* GetHeader + ** Retrieve header. Used in read_http to retrieve the HTTP header + */ + virtual char *GetHeader(char *name) { return 0; } + + /* ~WReader + ** WReader virtual destructor + */ + //virtual ~WReader() { } + virtual void Release(int)=0; +}; + + + + +/* DLL PLUGINS EXPORT STRUCTURES */ + +#define READ_VER 0x100 +#define IN_VER 0x100 +#define OF_VER 0x100 + + +typedef struct +{ + /* version + ** Version revision number + */ + int version; + + /* description + ** Text description of the reader plug-in + */ + char *description; + + /* create + ** Function pointer to create a reader module + */ + WReader *(*create)(); + + /* ismine + ** Determines whether or not a file should be read by this plug-in + */ + int (*ismine)(char *url); + +} reader_source; + + + + +typedef struct +{ + /* version + ** Version revision number + */ + int version; + + /* description + ** Text description of the input plug-in + */ + char *description; + + /* extension_list + ** Defines all the supported filetypes by this input plug-in + ** In semicolon delimited format ("ext;desc;ext;desc" etc). + */ + char *extension_list; + + /* ismine + ** called before extension checks, to allow detection of tone://,http://, etc + ** Determines whether or not a file type should be decoded by this plug-in + */ + int (*ismine)(char *filename); + + /* create + ** Function pointer to create a decoder module + */ + WInputSource *(*create)(void); + + /* createinfo + ** Function pointer to create a decoder module information + */ + WInputInfo *(*createinfo)(void); + +} input_source; + + + +typedef struct +{ + /* version + ** Version revision number + */ + int version; + + /* description + ** Text description of the output plug-in + */ + char *description; + + /* create + ** Function pointer to create an Output Filter + */ + WOutputFilter *(*create)(); + +} output_filter; + + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/decoder.cpp b/Src/Plugins/Input/in_vorbis/decoder.cpp new file mode 100644 index 00000000..54cd364e --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/decoder.cpp @@ -0,0 +1,459 @@ +#include "main.h" +#include "decoder.h" +#include <math.h> +#include <locale.h> +#pragma warning(disable:4244) +#include "shaper.h" +#include "api__in_vorbis.h" + +Decoder::~Decoder() {if (shaper) delete shaper;} + +extern CfgInt + cfg_mc6_dm, cfg_mc6_map; +/* +if (vorbis_cfg.use_hq_preamp) +{ + sample *= pow(10., preamp_db/20); + + //hard 6dB limiting + if (sample < -0.5) + sample = tanh((sample + 0.5) / (1-0.5)) * (1-0.5) - 0.5; + else if (sample > 0.5) + sample = tanh((sample - 0.5) / (1-0.5)) * (1-0.5) + 0.5; +} */ + +#if 0 +static float q_tanh(float x) +{ + double foo1, foo2; + foo1 = pow(2.71828182845904523536028747135266, x); + foo2 = 1.0 / foo1; + return (foo1 -foo2) / (foo1 + foo2); +} +#else +#define q_tanh tanh +#endif + +float VorbisFile::GetGain() +{ + float peak; + + vorbis_comment * c; + float scale = 1.0f; + c = ov_comment(&vf, -1); + peak = 0.99f; + if (c) + { + if (AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain", false)) + { + char * _peak = 0, *_gain = 0; + float gain = 0; + bool have_rg = 0; + float lwing_gain = 0; + char *gain1 = 0, *gain2 = 0, *peak1 = 0, *peak2 = 0; + gain1 = vorbis_comment_query(c, "replaygain_album_gain", 0); + if (!gain1) gain1 = vorbis_comment_query(c, "rg_audiophile", 0); + gain2 = vorbis_comment_query(c, "replaygain_track_gain", 0); + if (!gain2) gain2 = vorbis_comment_query(c, "rg_radio", 0); + + peak1 = vorbis_comment_query(c, "replaygain_album_peak", 0); + peak2 = vorbis_comment_query(c, "replaygain_track_peak", 0); + switch (AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"replaygain_source", 0)) + { + case 0: // track + _gain = gain2; + if (!_gain && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false)) + _gain = gain1; + _peak = peak2; + if (!_peak && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false)) + _peak = peak1; + break; + case 1: // album + _gain = gain1; + if (!_gain && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false)) + _gain = gain2; + _peak = peak1; + if (!_peak && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false)) + _peak = peak2; + break; + } + + if (!_peak) + { + _peak = vorbis_comment_query(c, "rg_peak", 0); + } + + _locale_t C_locale = WASABI_API_LNG->Get_C_NumericLocale(); + + if (_peak) peak = _atof_l(_peak, C_locale); + if (_gain) gain = _atof_l(_gain, C_locale); + + if (!_peak && !_gain) + { + char * l = vorbis_comment_query(c, "lwing_gain", 0); + if (l) + { + lwing_gain = _atof_l(l, C_locale); + have_rg = 1; + } + } + else have_rg = 1; + + if (!have_rg) + { + gain = AGAVE_API_CONFIG->GetFloat(playbackConfigGroupGUID, L"non_replaygain", -6.0f); + } + + scale = powf(10, (gain) / 20.0f); + if (lwing_gain) + scale *= lwing_gain; + else if (have_rg) + switch (AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"replaygain_mode", 1)) + { + case 1: // apply gain, but don't clip + if (scale*peak > 1.0) scale = 1.0 / peak; + break; + case 2: // normalize + scale = 1.0 / peak; + break; + case 3: // no clipping + if (peak > 1.0f) + scale = 1.0 / peak; + break; + } + } + } + + + return scale; +} + +void Decoder::process_rg() +{ + scale = file->GetGain(); +} + +void Decoder::setup_mc() +{ + if (AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"mono", false)) + nch = 1; + else if (src_nch == 6) + { + switch (cfg_mc6_dm) + { + case 2: + nch = 4; + break; + case 3: + case 4: + nch = 2; + break; + case 5: + nch = 1; + break; + } + + if (nch > 2 && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"surround", true)) + nch = 2; + } +} + +void Decoder::Flush() +{ + bptr = 0; + pcmbuf = 0; + data = 0; + pos = 0; + if (shaper) {delete shaper;shaper = 0;} +} + +void Decoder::Init(VorbisFile * f, UINT _bits, UINT _nch, bool _useFloat, bool allowRG) +{ + useFloat = _useFloat; + + file = f; + vorbis_info * i = ov_info(&file->vf, -1); + + if (allowRG) + process_rg(); + else + scale = 1.0f; + + if (useFloat) + { + dither = false; + bps = 32; + } + else + { + dither = AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"dither", true); + + if (_bits) + bps = _bits; + else + bps = AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"bits", 16); + } + + if (useFloat) + { + clipmin = -10000; // some arbitrarily large number + clipmax = 10000; // some arbitrarily large number + } + else + { + clipmin = - (1 << (bps - 1)); + clipmax = (1 << (bps - 1)) - 1; + } + sr = i->rate; + nch = src_nch = i->channels; + Flush(); + cur_link = file->vf.current_link; + + if (_nch) + nch = _nch; + else + setup_mc(); +} + +UINT Decoder::DataAvailable() +{ + return data * (bps >> 3); +} + +int Decoder::DoFrame() +{ + need_reopen = 0; + while (1) + { + data = ov_read_float(&file->vf, &pcmbuf, 576, 0); + if ((int)data <= 0) + { + if (data == OV_HOLE) {continue;} + data = 0; + return 0; + } + break; + } + + pos = 0; + if (cur_link != file->vf.current_link) + { + vorbis_info* i = ov_info(&file->vf, -1); + if (sr != (UINT)i->rate || src_nch != (UINT)i->channels) + { + UINT old_nch = nch, old_sr = sr; + if (shaper) {delete shaper;shaper = 0;} + sr = i->rate; + src_nch = nch = i->channels; + setup_mc(); + if (nch != old_nch || sr != old_sr) + { + need_reopen = 1; + } + } + process_rg(); + cur_link = file->vf.current_link; + } + data *= nch; + return 1; +} + +int Decoder::Read(UINT bytes, void * buf) +{ + UINT wr = 0; + if (buf && bytes && data > 0) + { + char* out = (char*)buf; + UINT d; + double mul; + int ofs; + float * img; + + d = bytes / (bps >> 3); + if (d > data) d = data; + if (!d) return 0; + data -= d; + if (useFloat) + { + mul = 1.0; + ofs = 0; + } + else + { + mul = (double)( (1 << ((bps) - 1)) - 1 ); + ofs = (bps == 8) ? 0x80 : 0; + } + wr += d * (bps >> 3); + + img = (float*)alloca(sizeof(float) * nch); + do + { + UINT cur_ch; + if (nch == 1 && src_nch > 0) + { + UINT c; + img[0] = 0; + for (c = 0;c < src_nch;c++) + { + img[0] += pcmbuf[c][pos]; + } + img[0] /= (float)src_nch; + } + else if (nch == src_nch && !(nch == 6 && cfg_mc6_dm == 1)) + { + UINT c; + for (c = 0;c < nch;c++) + { + img[c] = pcmbuf[c][pos]; + } + } + else if (src_nch == 6) + { + UINT FL, FR, C; + if (cfg_mc6_map == 1) + { + FL = 0; + FR = 1; + C = 2; + } + else + { + FL = 0; + C = 1; + FR = 2; + } + + if (nch == 6) + { //remap order for correct 5.1 output + img[0] = pcmbuf[FL][pos]; + img[1] = pcmbuf[FR][pos]; + img[2] = pcmbuf[C][pos]; + img[3] = pcmbuf[5][pos]; + img[4] = pcmbuf[3][pos]; + img[5] = pcmbuf[4][pos]; + } + else if (nch == 2) + { + /* + FL FR C BL BR LFE + 0 1 2 3 4 5 + + L,C,R,SL,SR,LFE + 0 1 2 3 4 5 + + + output: + FL FR C LFE BL BR + + + stereo: + Lt=L+0.707*(V-SL-SR+LFE) + Rt=R+0.707*(C+SL+SR+LFE) + + + Lt=L+0.707*(C+LFE) + Rt=R+0.707*(C+LFE) + SLt=SL + SRt=SR + + */ + if (cfg_mc6_dm == 4) //ds2 + { + const double a = pow(10., 1.5 / 20.), b = 1 / a; + img[0] = pcmbuf[FL][pos] + 0.707 * (pcmbuf[C][pos] - a * pcmbuf[3][pos] - b * pcmbuf[4][pos] + pcmbuf[5][pos]); + img[1] = pcmbuf[FR][pos] + 0.707 * (pcmbuf[C][pos] + b * pcmbuf[3][pos] + a * pcmbuf[4][pos] + pcmbuf[5][pos]); + } + else + { + img[0] = pcmbuf[FL][pos] + 0.707 * (pcmbuf[C][pos] - pcmbuf[3][pos] - pcmbuf[4][pos] + pcmbuf[5][pos]); + img[1] = pcmbuf[FR][pos] + 0.707 * (pcmbuf[C][pos] + pcmbuf[3][pos] + pcmbuf[4][pos] + pcmbuf[5][pos]); + } + } + else if (nch == 4) + { + img[0] = pcmbuf[FL][pos] + 0.707 * (pcmbuf[C][pos] + pcmbuf[5][pos]); + img[1] = pcmbuf[FR][pos] + 0.707 * (pcmbuf[C][pos] + pcmbuf[5][pos]); + img[2] = pcmbuf[3][pos]; + img[3] = pcmbuf[4][pos]; + } + } + + for (cur_ch = 0;cur_ch < nch;cur_ch++) + { + float v = img[cur_ch]; + int val; + v *= scale; + v *= mul; + if (dither) + { + if (!shaper) + { + //Shaper(int freq,int _nch,int min,int max,int _dtype,int pdf,double noiseamp); + shaper = new Shaper(sr, nch, clipmin, clipmax, 2, DITHER_TRIANGLE, 0); + } + // double peak=0; + val = shaper->do_shaping(v /*,&peak*/, cur_ch); + //shaper clips for us + } + else + { + val = (int)v; + if (val < clipmin) val = clipmin; + else if (val > clipmax) val = clipmax; + //1<<16 = 0x10000 + + } + val += ofs; + + switch (bps) + { + case 8: + *(BYTE*)out = (UINT)val; + break; + case 16: + *(short*)out = val; + break; + case 24: + { + ((BYTE*)out)[0] = (UINT)val; + ((BYTE*)out)[1] = (UINT)val >> 8; + ((BYTE*)out)[2] = (UINT)val >> 16; + } + break; + case 32: + if (useFloat) + { + *(float *)out = v; + } + else + { + //*(long*)out=val; + //break; + *(long*)out = 0; + } + break; + }; + out += (bps >> 3); + d--; + } + pos++; + } + while (d); + + } + return wr; +} + +int VorbisFile::Seek(double p) { return ov_time_seek(&vf, p);} + +int Decoder::Seek(double p) +{ + Flush(); + return file->Seek(p); +} + +//char *vorbis_comment_query(vorbis_comment *vc, char *tag, int count) +const char* VorbisFile::get_meta(const char* tag, UINT c) +{ + return vorbis_comment_query(vf.seekable ? vf.vc + vf.current_link : vf.vc, (char*)tag, c); +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/decoder.h b/Src/Plugins/Input/in_vorbis/decoder.h new file mode 100644 index 00000000..aa2b8c01 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/decoder.h @@ -0,0 +1,41 @@ +class Shaper; + +class Decoder +{ +private: + void process_rg(); + void setup_mc(); + float* bptr; + float** pcmbuf; + Shaper * shaper; + UINT data,pos; + float scale; + int cur_link; + int cur_preamp; + int clipmin,clipmax; +public: + VorbisFile * file; + + UINT nch,sr,kbps,bps,src_nch; + + Decoder() + { + memset(this,0,sizeof(*this)); + } + + ~Decoder(); + + int Seek(double p); + int Read(UINT bytes,void * buf); + void Flush(); + void Init(VorbisFile * f, UINT _bits=0, UINT _nch=0, bool _useFloat=false, bool allowRG=true); + void wa2_setinfo(UINT cur_bitrate); + + UINT DataAvailable(); + int DoFrame(); + bool need_reopen; + int play_init(); + bool play_inited; + bool dither; + bool useFloat; +};
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/genres.c b/Src/Plugins/Input/in_vorbis/genres.c new file mode 100644 index 00000000..3f71c504 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/genres.c @@ -0,0 +1,97 @@ +#include <windows.h> +#include "genres.h" +#include <shlwapi.h> + +extern const wchar_t *INI_DIRECTORY; + +static void file_init(wchar_t *file_path, wchar_t *fn) +{ + PathCombineW(file_path, INI_DIRECTORY, fn); +} + +static char eol[2]={13,10}; + +static char get_char(HANDLE f,BOOL * eof) +{ + DWORD br=0; + char r=0; + ReadFile(f,&r,1,&br,0); + if (!br) *eof=1; + return r; +} + +void genres_read(HWND wnd, wchar_t* fn) +{ + char temp[MAX_GENRE] = {0}; + char add[MAX_GENRE] = {0}; + BOOL eof=0; + char c = 0; + wchar_t file_path[MAX_PATH] = {0}; + HANDLE f; + + file_init(file_path, fn); + + f = CreateFileW(file_path, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); + if (f==INVALID_HANDLE_VALUE) return; + GetWindowTextA(wnd,add,MAX_GENRE); + while(!eof) + { + UINT ptr=0; + BOOL start=1; + while(ptr<MAX_GENRE-1) + { + c=get_char(f,&eof); + if (eof) break; + if (c==10 || c==13) + { + if (start) continue; + else break; + } + start=0; + temp[ptr++]=c; + } + if (ptr) + { + temp[ptr]=0; + SendMessage(wnd,CB_ADDSTRING,0, (LPARAM)temp); + if (add[0]) + { + if (!_stricmp(add,temp)) add[0]=0; + } + } + } + CloseHandle(f); + if (add[0]) SendMessage(wnd,CB_ADDSTRING,0,(LPARAM)add); +} + +void genres_write(HWND wnd, wchar_t* fn) +{ + wchar_t file_path[MAX_PATH] = {0}; + char temp[MAX_GENRE] = {0}; + UINT max = 0,n = 0; + DWORD bw = 0; + HANDLE f; + { + char add[MAX_GENRE] = {0}; + GetWindowTextA(wnd,add,MAX_GENRE); + if (!add[0]) return; + max=(UINT)SendMessage(wnd,CB_GETCOUNT,0,0); + for(n=0;n<max;n++) + { + SendMessage(wnd,CB_GETLBTEXT,n,(LPARAM)temp); + if (!_stricmp(temp,add)) return; + } + SendMessage(wnd,CB_ADDSTRING,0,(LPARAM)add); + } + file_init(file_path, fn); + f = CreateFileW(file_path, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0); + if (f==INVALID_HANDLE_VALUE) return; + max=(UINT)SendMessage(wnd,CB_GETCOUNT,0,0); + for(n=0;n<max;n++) + { + SendMessage(wnd,CB_GETLBTEXT,n,(LPARAM)temp); + bw = 0; WriteFile(f,temp,(DWORD)strlen(temp),&bw,0); + bw = 0; WriteFile(f,eol,2,&bw,0); + } + CloseHandle(f); +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/genres.h b/Src/Plugins/Input/in_vorbis/genres.h new file mode 100644 index 00000000..ad840701 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/genres.h @@ -0,0 +1,16 @@ +#ifndef NULLSOFT_IN_VORBIS_GENRES_H +#define NULLSOFT_IN_VORBIS_GENRES_H + +#ifdef __cplusplus +extern "C" { +#endif + +void genres_read(HWND wnd, wchar_t* fn); +void genres_write(HWND wnd, wchar_t* fn); +#define MAX_GENRE 256 + +#ifdef __cplusplus +} +#endif + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/http.cpp b/Src/Plugins/Input/in_vorbis/http.cpp new file mode 100644 index 00000000..87998084 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/http.cpp @@ -0,0 +1,596 @@ +#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; +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/in_vorbis.rc b/Src/Plugins/Input/in_vorbis/in_vorbis.rc new file mode 100644 index 00000000..a8d4b5e3 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/in_vorbis.rc @@ -0,0 +1,415 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// Polish resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_PLK) +#ifdef _WIN32 +LANGUAGE LANG_POLISH, SUBLANG_DEFAULT +#pragma code_page(1250) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "#include ""version.rc2""\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + +#endif // Polish resources +///////////////////////////////////////////////////////////////////////////// + + +///////////////////////////////////////////////////////////////////////////// +// 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 + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_ABOUT DIALOGEX 0, 0, 173, 113 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + CONTROL "",IDC_CUSTOM1,"XIPH_CLASS",0x0,6,8,44,40 + CTEXT "",IDC_RPM,7,56,45,8 + CTEXT "",IDC_RPM2,4,64,51,8 + LTEXT "",IDC_ABOUT_TEXT,58,8,110,85 + DEFPUSHBUTTON "OK",IDCANCEL,117,93,50,14 +END + +IDD_HTTPAUTH DIALOGEX 0, 0, 154, 70 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Ogg Authentication" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + LTEXT "Realm: ",IDC_STATIC,4,4,25,8 + LTEXT "",IDC_REALM,37,4,113,8 + LTEXT "Enter your login and password in the form of:\n\tlogin:password",IDC_STATIC,4,15,146,17 + EDITTEXT IDC_EDITAUTH,4,35,146,12,ES_AUTOHSCROLL + DEFPUSHBUTTON "OK",IDOKAUTH,4,52,50,13 + PUSHBUTTON "Cancel",IDCANCELAUTH,100,53,50,13 +END + +IDD_INFO_DLG_NEW DIALOGEX 0, 0, 329, 238 +STYLE DS_SETFONT | DS_FIXEDSYS | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME +CAPTION "Ogg Vorbis Info" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + LTEXT "File/URL :",-1,6,6,34,8 + EDITTEXT IDC_URL,43,5,282,12,ES_AUTOHSCROLL | ES_READONLY + GROUPBOX "File / Stream Info",IDC_STATIC_MISC,224,20,101,120 + EDITTEXT IDC_MISC,231,30,88,107,ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY | NOT WS_BORDER + GROUPBOX "Chained Streams",IDC_STATIC_CS,224,155,101,30 + PUSHBUTTON "<= previous",IDC_PREV_STREAM,229,167,44,13 + PUSHBUTTON "next =>",IDC_NEXT_STREAM,276,167,43,13 + CONTROL "Hide special fields",IDC_HIDE_SPEC,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,229,190,73,10 + PUSHBUTTON "",IDC_MODE_TOGGLE,228,203,93,13 + PUSHBUTTON "Close",IDCANCEL,273,220,48,13 +END + +IDD_INFO_PANEL_SIMPLE DIALOGEX 0, 0, 227, 218 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + GROUPBOX "Standard Tags",IDC_STATIC_STD,3,2,219,119 + LTEXT "Title",IDC_STATIC,29,16,14,8 + EDITTEXT IDC_TITLE,48,14,168,12,ES_AUTOHSCROLL + LTEXT "Artist",IDC_STATIC,27,32,16,8 + EDITTEXT IDC_ARTIST,48,30,168,12,ES_AUTOHSCROLL + LTEXT "Album",IDC_STATIC,24,48,19,8 + EDITTEXT IDC_ALBUM,48,46,124,12,ES_AUTOHSCROLL + LTEXT "Track:",IDC_STATIC_TRACK,175,48,21,8 + EDITTEXT IDC_TRACK,198,46,18,12,ES_AUTOHSCROLL + LTEXT "Year",IDC_STATIC,28,64,16,8 + EDITTEXT IDC_DATE,48,62,56,12,ES_AUTOHSCROLL + LTEXT "Genre",IDC_STATIC,117,64,22,8 + COMBOBOX IDC_GENRE,140,62,77,68,CBS_DROPDOWN | CBS_SORT | WS_VSCROLL | WS_TABSTOP + LTEXT "Comment",IDC_STATIC,13,80,29,8 + EDITTEXT IDC_COMMENT,48,78,169,37,ES_MULTILINE | ES_WANTRETURN | WS_VSCROLL + GROUPBOX "Other",IDC_STATIC_TAGS,3,123,219,91 + LISTBOX IDC_LIST,10,134,207,75,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP +END + +IDD_INFO_PANEL_ADVANCED DIALOGEX 0, 0, 227, 218 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + LISTBOX IDC_LIST,3,3,219,212,LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP +END + +IDD_INFO DIALOGEX 0, 0, 341, 164 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD | WS_SYSMENU +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "Advanced",IDC_STATIC,0,0,341,164 + CONTROL "",IDC_LIST,"SysListView32",LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP,6,13,164,143 + LTEXT "Name:",IDC_STATIC,175,13,22,8 + EDITTEXT IDC_NAME,175,23,159,14,ES_AUTOHSCROLL + LTEXT "Value:",IDC_STATIC,175,39,21,8 + EDITTEXT IDC_VALUE,175,49,159,90,ES_MULTILINE | ES_AUTOHSCROLL | ES_WANTRETURN | WS_VSCROLL + PUSHBUTTON "Add New",IDC_BUTTON_ADD,176,142,50,13 + PUSHBUTTON "Delete",IDC_BUTTON_DEL,230,142,50,13 + PUSHBUTTON "Delete All",IDC_BUTTON_DELALL,284,142,50,13 +END + +IDD_CONFIG DIALOGEX 0, 0, 222, 261 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "Decoding",IDC_STATIC,4,4,214,93 + CONTROL "Buffer full files from disk",IDC_FULLBUF,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,17,89,10 + CONTROL "Show average bitrate while playing",IDC_AVG_BR,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,31,128,10 + GROUPBOX "5.1-Channel Input Processing",IDC_STATIC,10,44,201,47 + LTEXT "Apply conversion:",IDC_STATIC,16,58,72,8,0,WS_EX_RIGHT + COMBOBOX IDC_MC6_DM,95,56,110,96,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + LTEXT "Source channel order:",IDC_STATIC,16,75,72,8,0,WS_EX_RIGHT + COMBOBOX IDC_MC6_MAP,95,73,110,96,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + GROUPBOX "Streaming",IDC_STATIC,4,101,214,139 + LTEXT "Buffer size",IDC_STATIC,10,115,34,8 + EDITTEXT IDC_HTTP_BSIZE,48,113,28,12,ES_AUTOHSCROLL | ES_NUMBER + LTEXT "KB",IDC_STATIC,80,115,9,8 + GROUPBOX "Prebuffering:",IDC_STATIC,10,129,201,44 + LTEXT "At start:",IDC_STATIC,16,142,31,8 + CONTROL "",IDC_SLIDER1,"msctls_trackbar32",TBS_NOTICKS | WS_TABSTOP,70,141,130,10 + LTEXT "After underrun:",IDC_STATIC,16,153,54,8 + CONTROL "",IDC_SLIDER2,"msctls_trackbar32",TBS_NOTICKS | WS_TABSTOP,70,152,130,10 + LTEXT "0%",IDC_STATIC,71,161,13,8 + LTEXT "50%",IDC_STATIC,122,161,18,8 + LTEXT "100%",IDC_STATIC,185,161,20,8 + LTEXT "Use Winamp's proxy server settings:",IDC_STATIC,10,179,120,8 + COMBOBOX IDC_PROXY,134,177,77,58,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + GROUPBOX "",IDC_STATIC,10,191,201,43 + CONTROL "Save streamed files to:",IDC_FSAVE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,201,89,10 + PUSHBUTTON "default",IDC_SSAVE_FMT_DEF,165,200,40,11 + PUSHBUTTON "",IDC_STREAM_SAVE,15,215,105,13 + EDITTEXT IDC_SSAVE_FMT,120,215,85,13,ES_AUTOHSCROLL + DEFPUSHBUTTON "OK",IDOK,124,244,45,13 + PUSHBUTTON "Cancel",IDCANCEL,173,244,45,13 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_ABOUT, DIALOG + BEGIN + LEFTMARGIN, 4 + RIGHTMARGIN, 168 + TOPMARGIN, 4 + BOTTOMMARGIN, 107 + END + + IDD_HTTPAUTH, DIALOG + BEGIN + LEFTMARGIN, 4 + RIGHTMARGIN, 150 + TOPMARGIN, 4 + BOTTOMMARGIN, 66 + END + + IDD_CONFIG, DIALOG + BEGIN + LEFTMARGIN, 4 + RIGHTMARGIN, 218 + TOPMARGIN, 4 + BOTTOMMARGIN, 257 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Bitmap +// + +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP9$(DISABLED) BITMAP "oggdrop\\120.bmp" +#else +IDB_BITMAP9 BITMAP "oggdrop\\120.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP8$(DISABLED) BITMAP "oggdrop\\119.bmp" +#else +IDB_BITMAP8 BITMAP "oggdrop\\119.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP7$(DISABLED) BITMAP "oggdrop\\118.bmp" +#else +IDB_BITMAP7 BITMAP "oggdrop\\118.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP6$(DISABLED) BITMAP "oggdrop\\117.bmp" +#else +IDB_BITMAP6 BITMAP "oggdrop\\117.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP5$(DISABLED) BITMAP "oggdrop\\116.bmp" +#else +IDB_BITMAP5 BITMAP "oggdrop\\116.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP4$(DISABLED) BITMAP "oggdrop\\115.bmp" +#else +IDB_BITMAP4 BITMAP "oggdrop\\115.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP3$(DISABLED) BITMAP "oggdrop\\114.bmp" +#else +IDB_BITMAP3 BITMAP "oggdrop\\114.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP2$(DISABLED) BITMAP "oggdrop\\113.bmp" +#else +IDB_BITMAP2 BITMAP "oggdrop\\113.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP12$(DISABLED) BITMAP "oggdrop\\123.bmp" +#else +IDB_BITMAP12 BITMAP "oggdrop\\123.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP11$(DISABLED) BITMAP "oggdrop\\122.bmp" +#else +IDB_BITMAP11 BITMAP "oggdrop\\122.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP10$(DISABLED) BITMAP "oggdrop\\121.bmp" +#else +IDB_BITMAP10 BITMAP "oggdrop\\121.bmp" +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDB_BITMAP1$(DISABLED) BITMAP "oggdrop\\112.bmp" +#else +IDB_BITMAP1 BITMAP "oggdrop\\112.bmp" +#endif +#endif + +///////////////////////////////////////////////////////////////////////////// +// +// PNG +// + +IDB_PNG1 PNG "oggdrop\\112.png" +IDB_PNG2 PNG "oggdrop\\113.png" +IDB_PNG3 PNG "oggdrop\\114.png" +IDB_PNG4 PNG "oggdrop\\115.png" +IDB_PNG5 PNG "oggdrop\\116.png" +IDB_PNG6 PNG "oggdrop\\117.png" +IDB_PNG7 PNG "oggdrop\\118.png" +IDB_PNG8 PNG "oggdrop\\119.png" +IDB_PNG9 PNG "oggdrop\\120.png" +IDB_PNG10 PNG "oggdrop\\121.png" +IDB_PNG11 PNG "oggdrop\\122.png" +IDB_PNG12 PNG "oggdrop\\123.png" + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + IDS_NULLSOFT_VORBIS_DECODER "Nullsoft Vorbis Decoder v%s" + 65535 "{5C5BCA4E-279E-4867-8E24-58C8B186959A}" +END + +STRINGTABLE +BEGIN + IDS_NULLSOFT_VORBIS_DECODER_OLD "Nullsoft Vorbis Decoder" + IDS_FILE_ERROR "file error" + IDS_LENGTH "Length: " + IDS_AVERAGE_BITRATE "Average bitrate: " + IDS_FILE_SIZE "File size: " + IDS_NOMINAL_BITRATE "Nominal bitrate: " + IDS_MIN_BITRATE "Min bitrate: " + IDS_MAX_BITRATE "Max bitrate: " + IDS_CHANNELS "Channels" + IDS_SAMPLING_RATE "Sampling rate" + IDS_SERIAL_NUMBER "Serial number" + IDS_VERSION "Version" +END + +STRINGTABLE +BEGIN + IDS_VENDOR "Vendor" + IDS_TO_SIMPLE_MODE "<< to simple mode" + IDS_TO_ADVANCED_MODE "to advanced mode >>" + IDS_OGG_VORBIS_INFO "Ogg Vorbis info - %s" + IDS_BEST_RPM "Best: %u RPM" + IDS_LEAVE_AS_IS "leave as is" + IDS_REMAP_6_CHANNELS "remap 6 channels" + IDS_DOWNMIX_TO_4_CHANNELS "downmix to 4 channels" + IDS_DOWNMIX_TO_2_CHANNELS_DS "downmix to 2 channels (DS)" + IDS_DOWNMIX_TO_2_CHANNELS_DS2 "downmix to 2 channels (DS2)" + IDS_DOWNMIX_TO_MONO "downmix to mono" + IDS_CORRECT_FL_FC_FR_BL_BR_LFE "correct (FL FC FR BL BR LFE)" + IDS_BROKEN_FL_FR_FC_BL_BR_LFE "broken (FL FR FC BL BR LFE)" +END + +STRINGTABLE +BEGIN + IDS_ABOUT_TEXT "%s\n© 2001-2023 Winamp SA\nWritten by: Peter Pawlowski\nBuild date: %hs\n\nThanks to:\n Craig Freer\n Tomi 'Nebularia' Jylhä-Ollila\n Jack Moffitt\n Szabolcs Péter" + IDS_TITLE_PREFERENCES "%s Preferences" + IDS_NEVER "never" + IDS_PORT_80_ONLY "port 80 only" + IDS_ALWAYS "always" + IDS_SELECT_OUTPUT_DIRECTORY "Select output directory:" +END + +STRINGTABLE +BEGIN + IDS_CONNECTING "Connecting..." + IDS_PREBUFFERING "Prebuffering : %u%%" + IDS_AUTH_REQUIRED "Authentication Required" + IDS_OGG_FILES "Ogg Vorbis Files (*.OGG;*.OGA)" + IDS_NAME "Name" + IDS_VALUE "Value" + IDS_KBPS "kbps" + IDS_HZ "Hz" + IDS_GAME_SPEED "%u RPM" + IDS_BYTES "bytes" + IDS_FAMILY_STRING "Ogg Vorbis File" +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +#include "version.rc2" + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/Src/Plugins/Input/in_vorbis/in_vorbis.sln b/Src/Plugins/Input/in_vorbis/in_vorbis.sln new file mode 100644 index 00000000..fe0c2e6d --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/in_vorbis.sln @@ -0,0 +1,65 @@ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29424.173 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "in_vorbis", "in_vorbis.vcxproj", "{7C58AC02-7941-42BE-8F97-9BF2064D6631}" + ProjectSection(ProjectDependencies) = postProject + {4FC28B55-2A14-43D5-86F7-201054F338A9} = {4FC28B55-2A14-43D5-86F7-201054F338A9} + {49238ED1-3146-49AB-9523-E9826EE4A0C8} = {49238ED1-3146-49AB-9523-E9826EE4A0C8} + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4} = {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libogg", "..\libogg\libogg.vcxproj", "{4FC28B55-2A14-43D5-86F7-201054F338A9}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vorbis_static", "..\libvorbis\win32\vorbis_static.vcxproj", "{49238ED1-3146-49AB-9523-E9826EE4A0C8}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vorbisfile_static", "..\libvorbis\win32\vorbisfile_static.vcxproj", "{EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {7C58AC02-7941-42BE-8F97-9BF2064D6631}.Debug|Win32.ActiveCfg = Debug|Win32 + {7C58AC02-7941-42BE-8F97-9BF2064D6631}.Debug|Win32.Build.0 = Debug|Win32 + {7C58AC02-7941-42BE-8F97-9BF2064D6631}.Release|Win32.ActiveCfg = Release|Win32 + {7C58AC02-7941-42BE-8F97-9BF2064D6631}.Release|Win32.Build.0 = Release|Win32 + {7C58AC02-7941-42BE-8F97-9BF2064D6631}.Debug|x64.ActiveCfg = Debug|x64 + {7C58AC02-7941-42BE-8F97-9BF2064D6631}.Debug|x64.Build.0 = Debug|x64 + {7C58AC02-7941-42BE-8F97-9BF2064D6631}.Release|x64.ActiveCfg = Release|x64 + {7C58AC02-7941-42BE-8F97-9BF2064D6631}.Release|x64.Build.0 = Release|x64 + {49238ED1-3146-49AB-9523-E9826EE4A0C8}.Debug|Win32.ActiveCfg = Debug|Win32 + {49238ED1-3146-49AB-9523-E9826EE4A0C8}.Debug|Win32.Build.0 = Debug|Win32 + {49238ED1-3146-49AB-9523-E9826EE4A0C8}.Release|Win32.ActiveCfg = Release|Win32 + {49238ED1-3146-49AB-9523-E9826EE4A0C8}.Release|Win32.Build.0 = Release|Win32 + {49238ED1-3146-49AB-9523-E9826EE4A0C8}.Debug|x64.ActiveCfg = Debug|x64 + {49238ED1-3146-49AB-9523-E9826EE4A0C8}.Debug|x64.Build.0 = Debug|x64 + {49238ED1-3146-49AB-9523-E9826EE4A0C8}.Release|x64.ActiveCfg = Release|x64 + {49238ED1-3146-49AB-9523-E9826EE4A0C8}.Release|x64.Build.0 = Release|x64 + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}.Debug|Win32.ActiveCfg = Debug|Win32 + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}.Debug|Win32.Build.0 = Debug|Win32 + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}.Release|Win32.ActiveCfg = Release|Win32 + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}.Release|Win32.Build.0 = Release|Win32 + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}.Debug|x64.ActiveCfg = Debug|x64 + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}.Debug|x64.Build.0 = Debug|x64 + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}.Release|x64.ActiveCfg = Release|x64 + {EC9475D2-FEE2-4F8C-9BB9-A11D5EB597C4}.Release|x64.Build.0 = Release|x64 + {4FC28B55-2A14-43D5-86F7-201054F338A9}.Debug|Win32.ActiveCfg = Debug|Win32 + {4FC28B55-2A14-43D5-86F7-201054F338A9}.Debug|Win32.Build.0 = Debug|Win32 + {4FC28B55-2A14-43D5-86F7-201054F338A9}.Release|Win32.ActiveCfg = Release|Win32 + {4FC28B55-2A14-43D5-86F7-201054F338A9}.Release|Win32.Build.0 = Release|Win32 + {4FC28B55-2A14-43D5-86F7-201054F338A9}.Debug|x64.ActiveCfg = Debug|x64 + {4FC28B55-2A14-43D5-86F7-201054F338A9}.Debug|x64.Build.0 = Debug|x64 + {4FC28B55-2A14-43D5-86F7-201054F338A9}.Release|x64.ActiveCfg = Release|x64 + {4FC28B55-2A14-43D5-86F7-201054F338A9}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {3248659F-0FFC-4CF4-A9BC-F7D10C713D5D} + EndGlobalSection +EndGlobal diff --git a/Src/Plugins/Input/in_vorbis/in_vorbis.vcxproj b/Src/Plugins/Input/in_vorbis/in_vorbis.vcxproj new file mode 100644 index 00000000..3bfe43ab --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/in_vorbis.vcxproj @@ -0,0 +1,339 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <ItemGroup Label="ProjectConfigurations"> + <ProjectConfiguration Include="Debug|Win32"> + <Configuration>Debug</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Debug|x64"> + <Configuration>Debug</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|Win32"> + <Configuration>Release</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|x64"> + <Configuration>Release</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + </ItemGroup> + <PropertyGroup Label="Globals"> + <ProjectGuid>{7C58AC02-7941-42BE-8F97-9BF2064D6631}</ProjectGuid> + <RootNamespace>in_vorbis</RootNamespace> + <WindowsTargetPlatformVersion>10.0.19041.0</WindowsTargetPlatformVersion> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <PlatformToolset>v142</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <PlatformToolset>v142</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <PlatformToolset>v142</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <PlatformToolset>v142</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> + <ImportGroup Label="ExtensionSettings"> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <PropertyGroup Label="UserMacros" /> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(PlatformShortName)_$(Configuration)\</OutDir> + <IntDir>$(PlatformShortName)_$(Configuration)\</IntDir> + <IncludePath>$(IncludePath)</IncludePath> + <LibraryPath>$(LibraryPath)</LibraryPath> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(PlatformShortName)_$(Configuration)\</OutDir> + <IntDir>$(PlatformShortName)_$(Configuration)\</IntDir> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(PlatformShortName)_$(Configuration)\</OutDir> + <IntDir>$(PlatformShortName)_$(Configuration)\</IntDir> + <IncludePath>$(IncludePath)</IncludePath> + <LibraryPath>$(LibraryPath)</LibraryPath> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(PlatformShortName)_$(Configuration)\</OutDir> + <IntDir>$(PlatformShortName)_$(Configuration)\</IntDir> + </PropertyGroup> + <PropertyGroup Label="Vcpkg"> + <VcpkgEnableManifest>false</VcpkgEnableManifest> + </PropertyGroup> + <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <VcpkgInstalledDir> + </VcpkgInstalledDir> + <VcpkgUseStatic>false</VcpkgUseStatic> + <VcpkgConfiguration>Debug</VcpkgConfiguration> + <VcpkgTriplet>x86-windows-static-md</VcpkgTriplet> + </PropertyGroup> + <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <VcpkgInstalledDir> + </VcpkgInstalledDir> + <VcpkgUseStatic>false</VcpkgUseStatic> + <VcpkgTriplet>x86-windows-static-md</VcpkgTriplet> + </PropertyGroup> + <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <VcpkgInstalledDir> + </VcpkgInstalledDir> + <VcpkgUseStatic>false</VcpkgUseStatic> + <VcpkgTriplet>x86-windows-static-md</VcpkgTriplet> + <VcpkgConfiguration>Debug</VcpkgConfiguration> + </PropertyGroup> + <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <VcpkgInstalledDir> + </VcpkgInstalledDir> + <VcpkgUseStatic>false</VcpkgUseStatic> + <VcpkgTriplet>x86-windows-static-md</VcpkgTriplet> + </PropertyGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <ClCompile> + <Optimization>Disabled</Optimization> + <IntrinsicFunctions>true</IntrinsicFunctions> + <AdditionalIncludeDirectories>.;..\..\..\Wasabi;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;WA2;TAGZ_UNICODE;UNICODE_INPUT_PLUGIN;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <MinimalRebuild>false</MinimalRebuild> + <MultiProcessorCompilation>true</MultiProcessorCompilation> + <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks> + <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> + <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation> + <ObjectFileName>$(IntDir)</ObjectFileName> + <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName> + <WarningLevel>Level3</WarningLevel> + <DebugInformationFormat>ProgramDatabase</DebugInformationFormat> + <DisableSpecificWarnings>4090;4312;4996;%(DisableSpecificWarnings)</DisableSpecificWarnings> + </ClCompile> + <ResourceCompile> + <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <Culture>0x0415</Culture> + </ResourceCompile> + <Link> + <AdditionalDependencies>shlwapi.lib;Msimg32.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile> + <GenerateDebugInformation>true</GenerateDebugInformation> + <ProgramDatabaseFile>$(IntDir)$(TargetName).pdb</ProgramDatabaseFile> + <SubSystem>Windows</SubSystem> + <RandomizedBaseAddress>false</RandomizedBaseAddress> + <ImportLibrary>$(IntDir)$(TargetName).lib</ImportLibrary> + <TargetMachine>MachineX86</TargetMachine> + <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers> + <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <MapFileName>$(IntDir)$(TargetName).map</MapFileName> + </Link> + <PostBuildEvent> + <Command>xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ +xcopy /Y /D $(IntDir)$(TargetName).pdb ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ </Command> + <Message>Post build event: 'xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\'</Message> + </PostBuildEvent> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <ClCompile> + <Optimization>Disabled</Optimization> + <IntrinsicFunctions>true</IntrinsicFunctions> + <AdditionalIncludeDirectories>.;..\..\..\Wasabi;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>WIN64;_DEBUG;_WINDOWS;WA2;TAGZ_UNICODE;UNICODE_INPUT_PLUGIN;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <MinimalRebuild>false</MinimalRebuild> + <MultiProcessorCompilation>true</MultiProcessorCompilation> + <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks> + <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> + <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation> + <ObjectFileName>$(IntDir)</ObjectFileName> + <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName> + <WarningLevel>Level3</WarningLevel> + <DebugInformationFormat>ProgramDatabase</DebugInformationFormat> + <DisableSpecificWarnings>4090;4312;4996;%(DisableSpecificWarnings)</DisableSpecificWarnings> + </ClCompile> + <ResourceCompile> + <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <Culture>0x0415</Culture> + </ResourceCompile> + <Link> + <AdditionalDependencies>shlwapi.lib;Msimg32.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile> + <GenerateDebugInformation>true</GenerateDebugInformation> + <ProgramDatabaseFile>$(IntDir)$(TargetName).pdb</ProgramDatabaseFile> + <SubSystem>Windows</SubSystem> + <RandomizedBaseAddress>false</RandomizedBaseAddress> + <ImportLibrary>$(IntDir)$(TargetName).lib</ImportLibrary> + <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers> + <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <MapFileName>$(IntDir)$(TargetName).map</MapFileName> + </Link> + <PostBuildEvent> + <Command>xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ +xcopy /Y /D $(IntDir)$(TargetName).pdb ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ </Command> + <Message>Post build event: 'xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\'</Message> + </PostBuildEvent> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <ClCompile> + <Optimization>MinSpace</Optimization> + <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion> + <FavorSizeOrSpeed>Size</FavorSizeOrSpeed> + <AdditionalIncludeDirectories>.;..\..\..\Wasabi;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;TAGZ_UNICODE;UNICODE_INPUT_PLUGIN;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <StringPooling>true</StringPooling> + <MultiProcessorCompilation>true</MultiProcessorCompilation> + <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> + <BufferSecurityCheck>true</BufferSecurityCheck> + <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation> + <ObjectFileName>$(IntDir)</ObjectFileName> + <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName> + <WarningLevel>Level3</WarningLevel> + <DebugInformationFormat>None</DebugInformationFormat> + <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed> + <DisableSpecificWarnings>4090;4312;4996;%(DisableSpecificWarnings)</DisableSpecificWarnings> + </ClCompile> + <ResourceCompile> + <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <Culture>0x0415</Culture> + </ResourceCompile> + <Link> + <AdditionalDependencies>shlwapi.lib;Msimg32.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile> + <GenerateDebugInformation>false</GenerateDebugInformation> + <ProgramDatabaseFile>$(IntDir)$(TargetName).pdb</ProgramDatabaseFile> + <MapFileName>$(IntDir)$(TargetName).map</MapFileName> + <SubSystem>Windows</SubSystem> + <OptimizeReferences>true</OptimizeReferences> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <RandomizedBaseAddress>false</RandomizedBaseAddress> + <ImportLibrary>$(IntDir)$(TargetName).lib</ImportLibrary> + <TargetMachine>MachineX86</TargetMachine> + <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers> + <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + </Link> + <PostBuildEvent> + <Command>xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ </Command> + <Message>Post build event: 'xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\'</Message> + </PostBuildEvent> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <ClCompile> + <Optimization>MinSpace</Optimization> + <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion> + <FavorSizeOrSpeed>Size</FavorSizeOrSpeed> + <AdditionalIncludeDirectories>.;..\..\..\Wasabi;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>WIN64;NDEBUG;_WINDOWS;TAGZ_UNICODE;UNICODE_INPUT_PLUGIN;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <StringPooling>true</StringPooling> + <MultiProcessorCompilation>true</MultiProcessorCompilation> + <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> + <BufferSecurityCheck>true</BufferSecurityCheck> + <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation> + <ObjectFileName>$(IntDir)</ObjectFileName> + <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName> + <WarningLevel>Level3</WarningLevel> + <DebugInformationFormat>None</DebugInformationFormat> + <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed> + <DisableSpecificWarnings>4090;4312;4996;%(DisableSpecificWarnings)</DisableSpecificWarnings> + </ClCompile> + <ResourceCompile> + <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <Culture>0x0415</Culture> + </ResourceCompile> + <Link> + <AdditionalDependencies>shlwapi.lib;Msimg32.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile> + <GenerateDebugInformation>false</GenerateDebugInformation> + <ProgramDatabaseFile>$(IntDir)$(TargetName).pdb</ProgramDatabaseFile> + <MapFileName>$(IntDir)$(TargetName).map</MapFileName> + <SubSystem>Windows</SubSystem> + <OptimizeReferences>true</OptimizeReferences> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <RandomizedBaseAddress>false</RandomizedBaseAddress> + <ImportLibrary>$(IntDir)$(TargetName).lib</ImportLibrary> + <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers> + <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + </Link> + <PostBuildEvent> + <Command>xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ </Command> + <Message>Post build event: 'xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\'</Message> + </PostBuildEvent> + </ItemDefinitionGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\external_dependencies\openmpt-trunk\include\vorbis\win32\vorbisfile_static.vcxproj"> + <Project>{ec9475d2-fee2-4f8c-9bb9-a11d5eb597c4}</Project> + </ProjectReference> + <ProjectReference Include="..\..\..\Wasabi\Wasabi.vcxproj"> + <Project>{3e0bfa8a-b86a-42e9-a33f-ec294f823f7f}</Project> + </ProjectReference> + </ItemGroup> + <ItemGroup> + <ClCompile Include="..\..\..\nsmkv\Lacing.cpp" /> + <ClCompile Include="..\..\..\nsmkv\vint.cpp" /> + <ClCompile Include="about.cpp" /> + <ClCompile Include="chainedstream_parse.cpp" /> + <ClCompile Include="config.cpp" /> + <ClCompile Include="c_string.cpp" /> + <ClCompile Include="decoder.cpp" /> + <ClCompile Include="ExtendedRead.cpp" /> + <ClCompile Include="genres.c" /> + <ClCompile Include="http.cpp" /> + <ClCompile Include="infobox.cpp" /> + <ClCompile Include="info_.cpp" /> + <ClCompile Include="localfile.cpp" /> + <ClCompile Include="mkv_vorbis_decoder.cpp" /> + <ClCompile Include="shaper.cpp" /> + <ClCompile Include="vcedit.c" /> + <ClCompile Include="wa2.cpp" /> + <ClCompile Include="winnt_helper.cpp" /> + </ItemGroup> + <ItemGroup> + <ClInclude Include="api__in_vorbis.h" /> + <ClInclude Include="c_string.h" /> + <ClInclude Include="decoder.h" /> + <ClInclude Include="genres.h" /> + <ClInclude Include="main.h" /> + <ClInclude Include="mkv_vorbis_decoder.h" /> + <ClInclude Include="resource.h" /> + <ClInclude Include="shaper.h" /> + <ClInclude Include="vcedit.h" /> + </ItemGroup> + <ItemGroup> + <ResourceCompile Include="in_vorbis.rc" /> + </ItemGroup> + <ItemGroup> + <Image Include="oggdrop\112.png" /> + <Image Include="oggdrop\113.png" /> + <Image Include="oggdrop\114.png" /> + <Image Include="oggdrop\115.png" /> + <Image Include="oggdrop\116.png" /> + <Image Include="oggdrop\117.png" /> + <Image Include="oggdrop\118.png" /> + <Image Include="oggdrop\119.png" /> + <Image Include="oggdrop\120.png" /> + <Image Include="oggdrop\121.png" /> + <Image Include="oggdrop\122.png" /> + <Image Include="oggdrop\123.png" /> + </ItemGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> + <ImportGroup Label="ExtensionTargets"> + </ImportGroup> +</Project>
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/in_vorbis.vcxproj.filters b/Src/Plugins/Input/in_vorbis/in_vorbis.vcxproj.filters new file mode 100644 index 00000000..6ce4ad5b --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/in_vorbis.vcxproj.filters @@ -0,0 +1,145 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <ItemGroup> + <ClCompile Include="winnt_helper.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="wa2.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="vcedit.c"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="shaper.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="mkv_vorbis_decoder.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="localfile.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="infobox.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="info_.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="http.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="genres.c"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="ExtendedRead.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="decoder.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="config.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="chainedstream_parse.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="c_string.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="about.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nsmkv\Lacing.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nsmkv\vint.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + </ItemGroup> + <ItemGroup> + <ClInclude Include="api__in_vorbis.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="c_string.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="decoder.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="genres.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="main.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="mkv_vorbis_decoder.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="resource.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="shaper.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="vcedit.h"> + <Filter>Header Files</Filter> + </ClInclude> + </ItemGroup> + <ItemGroup> + <Image Include="oggdrop\112.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\113.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\114.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\115.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\116.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\117.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\118.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\119.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\120.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\121.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\122.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="oggdrop\123.png"> + <Filter>Image Files</Filter> + </Image> + </ItemGroup> + <ItemGroup> + <Filter Include="Header Files"> + <UniqueIdentifier>{7c471b36-309f-402b-a247-e640a094f9bc}</UniqueIdentifier> + </Filter> + <Filter Include="Ressource Files"> + <UniqueIdentifier>{735fc214-c8e5-4619-8c70-a184a8373c92}</UniqueIdentifier> + </Filter> + <Filter Include="Source Files"> + <UniqueIdentifier>{00aa1653-baa3-4e88-b6d1-fa408b0c4a85}</UniqueIdentifier> + </Filter> + <Filter Include="Image Files"> + <UniqueIdentifier>{32126a2c-dd90-4901-a5e1-aee5b7363e37}</UniqueIdentifier> + </Filter> + </ItemGroup> + <ItemGroup> + <ResourceCompile Include="in_vorbis.rc"> + <Filter>Ressource Files</Filter> + </ResourceCompile> + </ItemGroup> +</Project>
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/info_.cpp b/Src/Plugins/Input/in_vorbis/info_.cpp new file mode 100644 index 00000000..687dc737 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/info_.cpp @@ -0,0 +1,658 @@ +//tag editor file i/o code, title formatting interface +#include "main.h" +#include "genres.h" +#include "../nu/AutoWide.h" +#include "../nu/AutoChar.h" +#include "../nu/ns_wc.h" +#include "api__in_vorbis.h" +#include <wchar.h> +#include <math.h> +#include <shlwapi.h> +#include "vcedit.h" +#include <strsafe.h> +#include "resource.h" + +namespace ogg_helper //chainedstream_parse +{ + int num_get_tracks(HANDLE hFile); + int query_chained_stream_offset(HANDLE hFile, int idx, __int64 * out_beginning, __int64 * out_end); +} + +/*static void xfer(HANDLE src, HANDLE dst, __int64 size) +{ + enum { BUFFER = 1024 * 1024 }; + void * buffer = malloc((int)(BUFFER > size ? size : BUFFER)); + while (size > 0) + { + int d = BUFFER; + if ((__int64)d > size) d = (int)size; + DWORD br = 0; + ReadFile(src, buffer, d, &br, 0); + WriteFile(dst, buffer, d, &br, 0); + size -= d; + } +}*/ + +static void seek64(HANDLE src, __int64 offset) +{ + __int64 temp = offset; + SetFilePointer(src, *(DWORD*)&temp, ((long*)&temp + 1), FILE_BEGIN); +} + +extern OSVERSIONINFO os_ver; +extern HANDLE hThread; + +static DWORDLONG get_space(const wchar_t * url) +{ + ULARGE_INTEGER free_space; + char zzz[4] = {(char)url[0], (char)url[1], (char)url[2], 0}; //"c:\"; + + free_space.QuadPart = 0; + + if (os_ver.dwPlatformId == VER_PLATFORM_WIN32_NT || (os_ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && LOWORD(os_ver.dwBuildNumber) > 1000)) + { + static BOOL (WINAPI* pGetDiskFreeSpaceEx)(LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER); + if (!pGetDiskFreeSpaceEx) + { + pGetDiskFreeSpaceEx = (BOOL (WINAPI*)(LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER))GetProcAddress(GetModuleHandle(L"kernel32.dll"), "GetDiskFreeSpaceExA"); + } + if (pGetDiskFreeSpaceEx) + { + ULARGE_INTEGER blah1, blah2; + pGetDiskFreeSpaceEx((LPCTSTR)zzz, &free_space, &blah1, &blah2); + } + } + if (!free_space.QuadPart) + { + DWORD spc, bps, nfc, tnc; + GetDiskFreeSpaceA(zzz, &spc, &bps, &nfc, &tnc); + free_space.QuadPart = UInt32x32To64(spc * bps, nfc); + } + return free_space.QuadPart; +} + +bool sync_movefile(const wchar_t * src, const wchar_t * dst); + +struct vcedit_param +{ + HANDLE hFile; + __int64 remaining; +}; + +static size_t callback_fread(void *ptr, size_t size, size_t nmemb, vcedit_param * param) +{ + int to_read = (int)(nmemb *size); + if (to_read > param->remaining) to_read = (int)param->remaining; + DWORD br = 0; + ReadFile(param->hFile, ptr, to_read, &br, 0); + param->remaining -= br; + return br / size; +} + +static size_t callback_write(const void *ptr, size_t size, size_t nmemb, HANDLE hFile) +{ + DWORD bw = 0; + WriteFile(hFile, ptr, (DWORD)(size*nmemb), &bw, 0); + return bw / size; +} + +BOOL modify_file(const wchar_t* url, const vorbis_comment * comments, int links) +{ //also used for stream save fix + HANDLE dst = INVALID_HANDLE_VALUE; + int scream = 0; + StringW tmp; + + winampGetExtendedFileInfoW_Cleanup(); + + tmp = url; + tmp += L".tmp"; + + HANDLE src = CreateFileW(url, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); + + if (src != INVALID_HANDLE_VALUE) + { + ULARGE_INTEGER src_size; + src_size.LowPart = GetFileSize(src, &src_size.HighPart); + if (src_size.QuadPart > get_space(url)) + { //shit happens... try default temp location + StringW tempdir; + GetTempPathW(MAX_PATH, StringTempW(tempdir, MAX_PATH)); + if (get_space(tempdir) < src_size.QuadPart) + { //oh well + CloseHandle(src); + src = INVALID_HANDLE_VALUE; + } + { + tmp = tempdir; + if (tmp[tmp.Length() - 1] != '\\') tmp.AddChar('\\'); + + StringCchPrintfW(StringTempW(tempdir, MAX_PATH), MAX_PATH, L"ogg%u_%u.tmp", GetTickCount(), GetCurrentProcessId()); + tmp.AddString(tempdir); + } + } + dst = CreateFileW(tmp, GENERIC_WRITE | GENERIC_READ, 0, 0, CREATE_ALWAYS, 0, 0); + } + + if (dst != INVALID_HANDLE_VALUE && src != INVALID_HANDLE_VALUE) + { + { + FILETIME ct; + GetFileTime(src, &ct, 0, 0); + SetFileTime(dst, &ct, 0, 0); + } + + int num_links = ogg_helper::num_get_tracks(src); + if (num_links < links) scream = 1; + else + { + int cur_link; + for (cur_link = 0; cur_link < links && !scream; cur_link++) + { + __int64 stream_beginning, stream_end; + if (ogg_helper::query_chained_stream_offset(src, cur_link, &stream_beginning, &stream_end)) + { + seek64(src, stream_beginning); + vcedit_state *vs; + vcedit_param param; + param.hFile = src; + param.remaining = stream_end - stream_beginning; + vs = vcedit_new_state(); + if (vcedit_open_callbacks(vs, ¶m, (vcedit_read_func)callback_fread, (vcedit_write_func)callback_write) < 0) + { + scream = 1; + } + else + { + vorbis_comment * vc = vcedit_comments(vs); + vorbis_comment_clear(vc); + vorbis_comment_init(vc); + const vorbis_comment * vc_src = comments + cur_link; + + int n; + for (n = 0;n < vc_src->comments;n++) + { + if (vc_src->user_comments[n]) + vorbis_comment_add(vc, vc_src->user_comments[n]); + } + + vcedit_write(vs, dst); + vcedit_clear(vs); + } + } + } + } + } + else scream = 1; + if (src != INVALID_HANDLE_VALUE) CloseHandle(src); + if (dst != INVALID_HANDLE_VALUE) + { + CloseHandle(dst); + if (scream) + { + DeleteFileW(tmp); + } + } + + if (!scream) + { + BOOL f_sync; + EnterCriticalSection(&sync); + + f_sync = !_wcsicmp(url, cur_file) && hThread; //check for i/o conflict with currently played file + LeaveCriticalSection(&sync); + if (f_sync) + { //drat, it's now playing + scream = !sync_movefile(tmp, url); + } + else + { + if (!DeleteFileW(url)) scream = 1; + else + { + if (!MoveFileW(tmp, url)) + { + if (!CopyFileW(tmp, url, 0)) scream = 1; + DeleteFileW(tmp); + } + } + } + } + if (scream) return 0; + else return 1; +} + +wchar_t *wdup(const char * src) +{ + return _wcsdup(StringW(src)); +} + +extern StringW stat_disp; + +void GetFileInfo(const wchar_t *file, wchar_t *title, int *len) +{ + VorbisFile* vf = 0; + BOOL is_cur_file = 0; + BOOL is_vf_local = 1; + if (title) *title = 0; + if (len) *len = -1; + + if (!file || !*file) + { + file = cur_file; + is_cur_file = 1; + } + else if (!lstrcmpiW(file, cur_file)) + { + is_cur_file = 1; + } + + if (title && stat_disp.Length() > 0 && is_cur_file) + { + lstrcpynW(title, stat_disp, 256); + title = 0; + } + + if (!len && !title) return ; + + if (is_cur_file) + { + EnterCriticalSection(&sync); + if (theFile) + { + vf = theFile; + is_vf_local = 0; + } + else + LeaveCriticalSection(&sync); + } + + if (!vf) + { + vf = VorbisFile::Create(file, 1); + if (!vf) + { + if (title) + { + lstrcpynW(title, PathFindFileNameW(file), 256); + wchar_t *blah = PathFindExtensionW(title); + *blah=0; + } + return ; + } + } + + if (len) + { + *len = (int)(vf->Length() * 1000); + } + + if (title) + { + const char *t = vf->get_meta("ARTIST", 0); + if (t) + { + MultiByteToWideCharSZ(CP_UTF8, 0, t, -1, title, 256); + t = vf->get_meta("TITLE", 0); + if (t) + { + StringCchCatW(title, 256, L" - "); + StringCchCatW(title, 256, AutoWide(t, CP_UTF8)); + } + } + else + { + const char *t = vf->get_meta("TITLE", 0); + if (t) + MultiByteToWideCharSZ(CP_UTF8, 0, t, -1, title, 256); + else + { + lstrcpynW(title, PathFindFileNameW(file), 256); + wchar_t *blah = PathFindExtensionW(title); + *blah=0; + } + } + } + //q: + if (is_vf_local) + delete vf; + else + LeaveCriticalSection(&sync); +} + +void w9x_itow(wchar_t *dest, int value, int destlen) +{ + StringCchPrintfW(dest, destlen, L"%d", value); + +} +void w9x_utow(wchar_t *dest, int value, int destlen) +{ + StringCchPrintfW(dest, destlen, L"%u", value); +} +void w9x_htow(wchar_t *dest, int value, int destlen) +{ + StringCchPrintfW(dest, destlen, L"%08x", value); +} + +static void print_misc(VorbisFile * _vf,int link,wchar_t * out, int outlen) +{ + OggVorbis_File * vf=&_vf->vf; + double t=ov_time_total(vf,link); + vorbis_info * vi=ov_info(vf,link); + vorbis_comment * vc=ov_comment(vf,link); + if (!vi || !vc) {WASABI_API_LNGSTRINGW_BUF(IDS_FILE_ERROR,out,outlen);return;} + + wchar_t kbps_str[16] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_KBPS, kbps_str, 16); + + wchar_t length[48]=L"", avgbitrate[48]=L"", filesize[48]=L"", nombitrate[48]=L"", maxbitrate[48]=L"", minbitrate[48]=L""; + if (t>0) + { + int h = (int)(t/3600.0); + int m = (int)(t/60.0)%60; + int s = (int)t%60; + + if(h>0) StringCchPrintfW(length,48,L"%s%u:%02u:%02u\r\n",WASABI_API_LNGSTRINGW(IDS_LENGTH),h,m,s); + else if(m>0) StringCchPrintfW(length,48,L"%s%u:%02u\r\n",WASABI_API_LNGSTRINGW(IDS_LENGTH),m,s); + else if(s>0) StringCchPrintfW(length,48,L"%s%u\r\n",WASABI_API_LNGSTRINGW(IDS_LENGTH),s); + + UINT fs=_vf->FileSize(); + if (fs>0) + { + int kbps = (int)(((double)fs)/(t*125.0)); + wchar_t tmp[32] = {0}; + StringCchPrintfW(avgbitrate,48,L"%s%u %s\r\n",WASABI_API_LNGSTRINGW(IDS_AVERAGE_BITRATE),kbps,kbps_str); + + int fs1=fs/1000000; + int fs2=(fs/1000)%1000; + int fs3=fs%1000; + if(fs1) + StringCchPrintfW(filesize,48,L"%s%u%03u%03u %s\r\n",WASABI_API_LNGSTRINGW(IDS_FILE_SIZE),fs1,fs2,fs3,WASABI_API_LNGSTRINGW_BUF(IDS_BYTES,tmp,32)); + else if(fs2) + StringCchPrintfW(filesize,48,L"%s%u%03u %s\r\n",WASABI_API_LNGSTRINGW(IDS_FILE_SIZE),fs2,fs3,WASABI_API_LNGSTRINGW_BUF(IDS_BYTES,tmp,32)); + else + StringCchPrintfW(filesize,48,L"%s%u %s\r\n",WASABI_API_LNGSTRINGW(IDS_FILE_SIZE),fs3,WASABI_API_LNGSTRINGW_BUF(IDS_BYTES,tmp,32)); + } + } + + if (vi->bitrate_nominal>0) + StringCchPrintfW(nombitrate,48,L"%s%u %s\r\n",WASABI_API_LNGSTRINGW(IDS_NOMINAL_BITRATE),vi->bitrate_nominal/1000,kbps_str); + + if (vi->bitrate_lower>0) + StringCchPrintfW(minbitrate,48,L"%s%u %s\r\n",WASABI_API_LNGSTRINGW(IDS_MIN_BITRATE),vi->bitrate_lower/1000,kbps_str); + + if (vi->bitrate_nominal>0) + StringCchPrintfW(maxbitrate,48,L"%s%u %s\r\n",WASABI_API_LNGSTRINGW(IDS_MAX_BITRATE),vi->bitrate_nominal/1000,kbps_str); + + wchar_t tmp[32] = {0}, tmp2[32] = {0}, tmp3[32] = {0}, tmp4[32] = {0}, tmp5[32] = {0}, hzStr[8] = {0}; + StringCchPrintfW(out,outlen,L"%s%s%s%s%s%s%s: %u\r\n%s: %u %s\r\n%s: %u\r\n%s: %u\r\n%s: \r\n%s", + length, avgbitrate, filesize, nombitrate, maxbitrate, minbitrate, + WASABI_API_LNGSTRINGW_BUF(IDS_CHANNELS,tmp,32),vi->channels, + WASABI_API_LNGSTRINGW_BUF(IDS_SAMPLING_RATE,tmp2,32),vi->rate, WASABI_API_LNGSTRINGW_BUF(IDS_HZ,hzStr,8), + WASABI_API_LNGSTRINGW_BUF(IDS_SERIAL_NUMBER,tmp3,32),ov_serialnumber(vf,link), + WASABI_API_LNGSTRINGW_BUF(IDS_VERSION,tmp4,32),vi->version, + WASABI_API_LNGSTRINGW_BUF(IDS_VENDOR,tmp5,32),(wchar_t*)AutoWide(vc->vendor,CP_UTF8)); +} + +static VorbisFile* last_vf = 0; +static wchar_t last_file[MAX_PATH] = {0}; +static FILETIME ftLastWriteTime; + +// is used to determine if the last write time of the file has changed when +// asked to get the metadata for the same cached file so we can update things +BOOL HasFileTimeChanged(const wchar_t *fn) +{ + WIN32_FILE_ATTRIBUTE_DATA fileData = {0}; + if (GetFileAttributesExW(fn, GetFileExInfoStandard, &fileData) == TRUE) + { + if(CompareFileTime(&ftLastWriteTime, &fileData.ftLastWriteTime)) + { + ftLastWriteTime = fileData.ftLastWriteTime; + return TRUE; + } + } + return FALSE; +} + +void UpdateFileTimeChanged(const wchar_t *fn) +{ + WIN32_FILE_ATTRIBUTE_DATA fileData; + if (GetFileAttributesExW(fn, GetFileExInfoStandard, &fileData) == TRUE) + { + ftLastWriteTime = fileData.ftLastWriteTime; + } +} + +// need to call this when we shut down just to make sure things are correctly cleaned up +//(the joys of caching for speed) +void winampGetExtendedFileInfoW_Cleanup(void) +{ + if (last_vf) + { + delete last_vf; + last_vf = 0; + } + last_file[0] = 0; +} + +static void CALLBACK winampGetExtendedFileInfoW_Timer(HWND hwnd, UINT uMsg, UINT_PTR eventId, DWORD elapsed) +{ + // TODO need to do a better way of getting and caching the metadata + // this is _just_ a temp fix for the file being locked when it + // it really needs 'class Info' to be able to cache and read. + KillTimer(hwnd, eventId); + winampGetExtendedFileInfoW_Cleanup(); +} + +bool KeywordMatch(const char *mainString, const char *keyword) +{ + return !_stricmp(mainString, keyword); +} + +#define START_TAG_ALIAS(name, alias) if (KeywordMatch(data, name)) lookup=alias +#define TAG_ALIAS(name, alias) else if (KeywordMatch(data, name)) lookup=alias +extern "C" __declspec( dllexport ) int winampGetExtendedFileInfoW(const wchar_t *fn, const char *data, wchar_t *dest, int destlen) +{ + if (!_stricmp(data, "type")) + { + dest[0] = '0'; + dest[1] = 0; + return 1; + } + else if (!_stricmp(data, "rateable")) + { + dest[0] = '1'; + dest[1] = 0; + return 1; + } + else if (!_stricmp(data, "streammetadata")) + { + return 0; + } + + if (!fn || (fn && !fn[0])) return 0; + + if (!_stricmp(data, "family")) + { + LPCWSTR e; + int pID = -1; + DWORD lcid; + e = PathFindExtensionW(fn); + if (L'.' != *e) return 0; + e++; + lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT); + if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"OGG", -1) || + CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"OGA", -1)) pID = IDS_FAMILY_STRING; + if (pID != -1 && S_OK == StringCchCopyW(dest, destlen, WASABI_API_LNGSTRINGW(pID))) return 1; + return 0; + } + + if (!_stricmp(data, "mime")) + { + StringCchCopyW(dest, destlen, L"audio/ogg"); + return 1; + } + + // attempt to cache/use a cached instance of VorbisFile to speed up metadata queries + // which is especially needed with large ogg files (like with a 4Mb embedded image!) + VorbisFile* vf = 0; + if(last_file[0] && !_wcsicmp(last_file, fn) && !HasFileTimeChanged(fn)) + { + vf = last_vf; + } + else + { + // different file so clean up if there's a cached instance + if(last_vf) + { + delete last_vf; + last_vf = 0; + } + // open the new file and cache the current filename for subsequent query checks + vf = VorbisFile::Create(fn, 1); + lstrcpynW(last_file, fn, MAX_PATH); + } + + if (!vf) return 0; + else last_vf = vf; + + // TODO need to do a better way of getting and caching the metadata + // this is _just_ a temp fix for the file being locked when it + // it really needs 'class Info' to be able to cache and read. + SetTimer(mod.hMainWindow, 256, 2000, winampGetExtendedFileInfoW_Timer); + + const char *lookup = 0; + if (!_stricmp(data, "length")) + { + int len = (int)(vf->Length() * 1000); + w9x_itow(dest, len, destlen); + return 1; + } + else if (!_stricmp(data, "bitrate")) + { + int br = vf->get_avg_bitrate(); + w9x_itow(dest, br, destlen); + return 1; + } + else if (!_stricmp(data, "SERIALNUMBER")) + { + w9x_utow(dest, ov_serialnumber(&vf->vf, -1), destlen); + return 1; + } + else if (!_stricmp(data, "SERIALNUMBER_HEX")) + { + w9x_htow(dest, ov_serialnumber(&vf->vf, -1), destlen); + return 1; + } + else if (!_stricmp(data, "gain")) + { + float gain = 20.0f*(float)log10(vf->GetGain()); + StringCchPrintfW(dest, destlen, L"%-+.2f dB", gain); + return 1; + } + else if(!_stricmp(data,"formatinformation")) + { + print_misc(vf,0,dest,destlen); + return 1; + } + TAG_ALIAS("title", "TITLE"); + TAG_ALIAS("artist", "ARTIST"); + TAG_ALIAS("album", "ALBUM"); + TAG_ALIAS("genre", "GENRE"); + TAG_ALIAS("comment", "COMMENT"); + TAG_ALIAS("year", "DATE"); + TAG_ALIAS("track", "TRACKNUMBER"); + TAG_ALIAS("albumartist", "ALBUMARTIST"); + TAG_ALIAS("composer", "COMPOSER"); + TAG_ALIAS("disc", "DISCNUMBER"); + TAG_ALIAS("publisher", "PUBLISHER"); + TAG_ALIAS("conductor", "CONDUCTOR"); + TAG_ALIAS("tool", "ENCODED-BY"); + TAG_ALIAS("replaygain_track_gain", "REPLAYGAIN_TRACK_GAIN"); + TAG_ALIAS("replaygain_track_peak", "REPLAYGAIN_TRACK_PEAK"); + TAG_ALIAS("replaygain_album_gain", "REPLAYGAIN_ALBUM_GAIN"); + TAG_ALIAS("replaygain_album_peak", "REPLAYGAIN_ALBUM_PEAK"); + TAG_ALIAS("GracenoteFileID", "GRACENOTEFILEID"); + TAG_ALIAS("GracenoteExtData", "GRACENOTEEXTDATA"); + TAG_ALIAS("bpm", "BPM"); + TAG_ALIAS("remixing", "REMIXING"); + TAG_ALIAS("subtitle", "VERSION"); + TAG_ALIAS("isrc", "ISRC"); + TAG_ALIAS("category", "CATEGORY"); + TAG_ALIAS("rating", "RATING"); + TAG_ALIAS("producer", "PRODUCER"); + + if (!lookup) + return 0; + + const char *value = vf->get_meta(lookup, 0); + + if(KeywordMatch("comment",data)) { + if(!value || !*value) value = vf->get_meta("DESCRIPTION", 0); + } + + if(KeywordMatch("year",data)) { + if(!value || !*value) value = vf->get_meta("YEAR", 0); + } + + if(KeywordMatch("track",data)) { + if(!value || !*value) value = vf->get_meta("TRACK", 0); + } + + if(KeywordMatch("albumartist",data)) { + if(!value || !*value) value = vf->get_meta("ALBUM ARTIST", 0); + if(!value || !*value) value = vf->get_meta("ENSEMBLE", 0); + } + + if(KeywordMatch("publisher",data)) { + if(!value || !*value) value = vf->get_meta("ORGANIZATION", 0); + } + + if(KeywordMatch("category",data)) { + if(!value || !*value) value = vf->get_meta("CONTENTGROUP", 0); + if(!value || !*value) value = vf->get_meta("GROUPING", 0); + } + + if(KeywordMatch(data, "rating")) { + if(!value || !*value) value = vf->get_meta("RATING", 0); + if(value && *value) { + int rating = atoi(value); + // keeps things limited to our range of 0-100 + if (rating >= 100) { + rating = 5; + } + // 1-100 case + else if (rating > 5 && rating < 100) { + rating /= 20; + // shift up by one rating when in next band + // 1-20 = 1, 21-40 = 2, 41-60 = 3, 61-80 = 4, 81-100 = 5 + rating += ((atoi(value) - (rating * 20)) > 0); + } + // Remove support for old 1-10 range + /* or maybe we're dealing with a 1-10 range + else if (rating > 5) { + rating /= 2; + } */ + + // otherwise it is hopefully in the 0-5 range + else if (rating > 0 && rating <= 5) { + } + // otherwise just make sure and set zero + else { + rating = 0; + } + + StringCchPrintfW(dest, destlen, L"%u", rating); + return 1; + } + } + + if(value) + MultiByteToWideCharSZ(CP_UTF8, 0, value, -1, dest, destlen); + else + { + dest[0]=0; + return 1; + } + + return 1; +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/infobox.cpp b/Src/Plugins/Input/in_vorbis/infobox.cpp new file mode 100644 index 00000000..30d90056 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/infobox.cpp @@ -0,0 +1,1457 @@ +#include "main.h" +#include "api__in_vorbis.h" +#include "genres.h" +#include <commctrl.h> +#include "../Agave/Language/api_language.h" +#include "../nu/AutoWide.h" +#include "../nu/AutoChar.h" +#include "resource.h" +#include <strsafe.h> + +extern In_Module mod; +/* old PP info box. still used for streams */ + + +extern CfgFont cfg_font; + +extern CfgInt cfg_modeless,cfg_remember_infosize; + +static CfgInt + cfg_hide_special_fields("hide_special_fields",1), + cfg_adv_info("adv_info",0), + cfg_infobox_sx("infobox_sx",0), + cfg_infobox_sy("infobox_sy",0), + cfg_infobox_x("infobox_x",0), + cfg_infobox_y("infobox_y",0); + +void SetDlgItemTextWrap(HWND w,UINT id,wchar_t * tx) +{ + SetDlgItemTextW(w,id,tx); +} + +typedef struct +{ + UINT id; + wchar_t * name; +} STD_TAG_ITEM; + +#define N_STD_TAGZ 7 + +extern BOOL cfg_adv_warn; + +static const STD_TAG_ITEM std_tagz[N_STD_TAGZ]= +{ + {IDC_TITLE,L"TITLE"}, + {IDC_ARTIST,L"ARTIST"}, + {IDC_ALBUM,L"ALBUM"}, + {IDC_GENRE,L"GENRE"}, + {IDC_DATE,L"DATE"}, + {IDC_COMMENT,L"COMMENT"}, + {IDC_TRACK,L"TRACKNUMBER"}, +}; + +const wchar_t * special_fields[]={L"RG_PEAK",L"RG_RADIO",L"RG_AUDIOPHILE",L"LWING_GAIN",L"REPLAYGAIN_ALBUM_GAIN",L"REPLAYGAIN_ALBUM_PEAK",L"REPLAYGAIN_TRACK_GAIN",L"REPLAYGAIN_TRACK_PEAK"}; +#define N_SPECIAL_FIELDS (sizeof(special_fields)/sizeof(special_fields[0])) + + +typedef struct tagTAG +{ + tagTAG * next; + wchar_t * name; + wchar_t * value; +} TAG; + +typedef struct +{ + wchar_t *name,*value; +} TAGDESC; + +class OggTagData +{ +public: + TAG * tags; + TAG ** last; + TAG * newtag() + { + TAG * t=new TAG; + *last=t; + last=&t->next; + t->next=0; + return t; + } + + OggTagData() + { + tags=0; + last=&tags; + } + + String vendor; + + OggTagData(vorbis_comment * vc) : vendor(vc->vendor) + { + tags=0; + last=&tags; + int n; + for(n=0;n<vc->comments;n++) + { + TAG * t=newtag(); + char * c=vc->user_comments[n]; + char * p=strchr(c,'='); + if (p) + { + int size = MultiByteToWideChar(CP_UTF8, 0, c, (int)(p-c), 0,0); + t->name=(wchar_t*)malloc((size+1)*sizeof(wchar_t)); + MultiByteToWideChar(CP_UTF8, 0, c, (int)(p-c), t->name, size); + t->name[size]=0; + p++; + } + else + { + t->name=_wcsdup(L"COMMENT"); + p=c; + } + + int size = MultiByteToWideChar(CP_UTF8, 0, p, -1, 0,0); + t->value=(wchar_t*)malloc((size)*sizeof(wchar_t)); + MultiByteToWideChar(CP_UTF8, 0, p, -1, t->value, size); + } + } + void Clear() + { + TAG * t=tags; + while(t) + { + TAG * t1=t->next; + free(t->name); + free(t->value); + delete t; + t=t1; + } + tags=0; + last=&tags; + } + void AddTag(const wchar_t * name,const wchar_t * value) + { + TAG * t=newtag(); + t->name=_wcsdup(name); + t->value=_wcsdup(value); + } + ~OggTagData() + { + Clear(); + } +}; + +static void SetWindowRect(HWND w,RECT * r) +{ + SetWindowPos(w,0,r->left,r->top,r->right-r->left,r->bottom-r->top,SWP_NOZORDER|SWP_NOCOPYBITS|SWP_NOACTIVATE); +} + +class DlgBase +{ +protected: + bool DieOnDestroyWindow,is_modeless,is_modal_ex,modal_ex_quit; + int modal_ex_quit_val; + + void endDialog(int x) + { + if (is_modeless) DestroyWindow(wnd); + else if (is_modal_ex) + { + modal_ex_quit=1; + modal_ex_quit_val=x; + DestroyWindow(wnd); + } + else EndDialog(wnd,x); + } + + void _do_size_x(RECT * r,UINT id,UINT wx,UINT min_x) + { + RECT r1={r->left,r->top,(LONG)(wx-min_x)+r->right,r->bottom}; + SetWindowRect(GetDlgItem(wnd,id),&r1); + } + + void _do_size_xy(RECT * r,UINT id,UINT wx,UINT wy,UINT min_x,UINT min_y) + { + RECT r1={r->left,r->top,(LONG)(wx-min_x)+r->right,(LONG)(wy-min_y)+r->bottom}; + SetWindowRect(GetDlgItem(wnd,id),&r1); + } + + void _do_align_x_size_y(RECT * r,UINT id,UINT wx,UINT wy,UINT min_x,UINT min_y) + { + RECT r1={ (LONG)(wx-min_x)+r->left,r->top,(LONG)(wx-min_x)+r->right,(LONG)(wy-min_y)+r->bottom}; + SetWindowRect(GetDlgItem(wnd,id),&r1); + } + + void _do_align_x(RECT * r,UINT id,UINT wx,UINT min_x) + { + RECT r1={ (LONG)(wx-min_x+r)->left,(LONG)r->top,(LONG)(wx-min_x+r)->right,(LONG)r->bottom}; + SetWindowRect(GetDlgItem(wnd,id),&r1); + } + + void _do_align_xy(RECT * r,UINT id,UINT wx,UINT wy,UINT min_x,UINT min_y) + { + RECT r1={(LONG)(wx-min_x+r)->left,(LONG)(wy-min_y+r)->top,(LONG)(wx- min_x+r)->right,(LONG)(wy-min_y+r)->bottom}; + SetWindowRect(GetDlgItem(wnd,id),&r1); + } + +#define do_size_x(id,r) _do_size_x(r,id,sx,min_size_x) +#define do_size_xy(id,r) _do_size_xy(r,id,sx,sy,min_size_x,min_size_y) +#define do_align_x_size_y(id,r) _do_align_x_size_y(r,id,sx,sy,min_size_x,min_size_y) +#define do_align_xy(id,r) _do_align_xy(r,id,sx,sy,min_size_x,min_size_y) +#define do_align_x(id,r) _do_align_x(r,id,sx,min_size_x) + + HWND wnd; + UINT min_size_x,min_size_y; + UINT min_size_x_w,min_size_y_w; + + void do_sizing(UINT wp,RECT * r) + { + UINT dx,dy; + dx=r->right-r->left; + dy=r->bottom-r->top; + if (dx<min_size_x_w) + { + switch(wp) + { + case WMSZ_BOTTOMLEFT: + case WMSZ_LEFT: + case WMSZ_TOPLEFT: + r->left=r->right-min_size_x_w; + break; + case WMSZ_BOTTOMRIGHT: + case WMSZ_RIGHT: + case WMSZ_TOPRIGHT: + r->right=r->left+min_size_x_w; + break; + } + } + if (dy<min_size_y_w) + { + switch(wp) + { + case WMSZ_BOTTOMLEFT: + case WMSZ_BOTTOM: + case WMSZ_BOTTOMRIGHT: + r->bottom=r->top+min_size_y_w; + break; + case WMSZ_TOPLEFT: + case WMSZ_TOP: + case WMSZ_TOPRIGHT: + r->top=r->bottom-min_size_y_w; + break; + } + } + } + void MakeComboEdit(UINT id,DWORD s) + { + HWND w=GetDlgItem(wnd,id); + RECT r; + GetChildRect(id,r); + DestroyWindow(w); + CreateWindowEx( WS_EX_CLIENTEDGE, L"EDIT", 0, WS_CHILD | s, r.left - 1, r.top - 1, r.right - r.left, r.bottom - r.top, wnd, (HMENU)id, 0, 0 ); + } + void GetChildRect(UINT id,RECT& child) + { + RECT r_parent,r_child; + GetWindowRect(wnd,&r_parent); + GetWindowRect(GetDlgItem(wnd,id),&r_child); + int dx=r_parent.left; + int dy=r_parent.top; + if (!(GetWindowLong(wnd,GWL_STYLE)&WS_CHILD)) + { + dy+=GetSystemMetrics(SM_CYCAPTION)+GetSystemMetrics(SM_CYDLGFRAME); + dx+=GetSystemMetrics(SM_CXDLGFRAME); + } + child.left=r_child.left-dx; + child.right=r_child.right-dx; + child.top=r_child.top-dy; + child.bottom=r_child.bottom-dy; + } + + virtual BOOL DlgProc(UINT msg,WPARAM wp,LPARAM lp) {return 0;}; + static BOOL CALLBACK TheDialogProc(HWND wnd,UINT msg,WPARAM wp,LPARAM lp) + { + DlgBase * p; + if (msg==WM_INITDIALOG) + { + p=(DlgBase*)lp; +#ifdef WIN64 + SetWindowLong(wnd, DWLP_USER, (LONG)lp); +#else + SetWindowLong(wnd, DWL_USER, lp); +#endif + p->wnd=wnd; + RECT r; + GetClientRect(wnd,&r); + p->min_size_x=r.right; + p->min_size_y=r.bottom; + GetWindowRect(wnd,&r); + p->min_size_x_w=r.right-r.left; + p->min_size_y_w=r.bottom-r.top; + } +#ifdef WIN64 + else p = (DlgBase*)GetWindowLong(wnd, DWLP_USER); +#else + else p = (DlgBase*)GetWindowLong(wnd, DWL_USER); +#endif + BOOL rv=0; + if (p) + { + rv=p->DlgProc(msg,wp,lp); + if (msg==WM_DESTROY) + { + p->wnd=0; + if (p->DieOnDestroyWindow) + { + delete p; +#ifdef WIN64 + SetWindowLong(wnd, DWLP_USER, 0); +#else + SetWindowLong(wnd, DWL_USER, 0); +#endif + } + } + } + return rv; + } + HWND myCreateDialog(UINT id,HWND parent) + { + DieOnDestroyWindow=1; + is_modeless=1; + is_modal_ex=0; + return WASABI_API_CREATEDIALOGPARAMW(id,parent,TheDialogProc,(LPARAM)this); + } + virtual void myProcessMessage(MSG * msg) + { + if (!IsDialogMessage(wnd,msg)) + { + TranslateMessage(msg); + DispatchMessage(msg); + } + } + + int myDialogBoxEx(UINT id,HWND parent) + { + DieOnDestroyWindow=0; + is_modeless=0; + is_modal_ex=1; + modal_ex_quit=0; + modal_ex_quit_val=-1; + WASABI_API_CREATEDIALOGPARAMW(id,parent,TheDialogProc,(LPARAM)this); + if (wnd) + { + BOOL b=IsWindowEnabled(parent); + + if (b) EnableWindow(parent,0); + + MSG msg; + while(!modal_ex_quit && GetMessage(&msg,0,0,0)) + { + myProcessMessage(&msg); + } + + if (wnd) + { + DestroyWindow(wnd); + wnd=0; + } + + if (b) EnableWindow(parent,1); + SetActiveWindow(parent); + } + return modal_ex_quit_val; + } + + int myDialogBox(UINT id,HWND parent) + { + DieOnDestroyWindow=0; + is_modeless=0; + is_modal_ex=0; + return (int)WASABI_API_DIALOGBOXPARAMW(id,parent,TheDialogProc,(LPARAM)this); + } + DlgBase() + { + wnd=0; + DieOnDestroyWindow=0; + is_modeless=0; + is_modal_ex=0; + modal_ex_quit=0; + modal_ex_quit_val=0; + min_size_x=min_size_y=min_size_x_w=min_size_y_w=0; + } + virtual ~DlgBase() {DieOnDestroyWindow=0;if (wnd) DestroyWindow(wnd);} +public: + BOOL isDialogMessage(MSG * m) {return wnd ? IsDialogMessage(wnd,m) : 0;} +}; + +static char tags_file[]="tags.txt"; +static wchar_t genres_file[] = L"genres.txt"; + +class /*_declspec(novtable) */InfoDlgPanel : public DlgBase +{ +protected: + HFONT font; + HWND list; + RECT info_list; + OggTagData hidden; + + InfoDlgPanel(UINT id,HWND parent,HFONT foo) + { + font=foo; + myCreateDialog(id,parent); + //SetWindowLong(wnd,GWL_STYLE,GetWindowLong(wnd,GWL_STYLE)|WS_TABSTOP); + list=GetDlgItem(wnd,IDC_LIST); + SendMessage(list,WM_SETFONT,(WPARAM)font,0); + + GetChildRect(IDC_LIST,info_list); + } + + int lb_addstring(TAGDESC * tag,int idx=-1) + { + StringW tmp; + tmp+=tag->name; + tmp+=L"="; + tmp+=tag->value; + + const WCHAR * p=(const WCHAR*)tmp; + const WCHAR * foo=wcsstr(p,L"\x0d\x0a"); + if (foo) + { + tmp.Truncate((UINT)(foo-p)); + tmp.AddString(L" (...)"); + } + int rv= + (int)SendMessageW(list, + idx<0 ? LB_ADDSTRING : LB_INSERTSTRING, + idx<0 ? 0 : idx, + ((LPARAM)(const WCHAR*)tmp) + ); + if (rv>=0) SendMessage(list,LB_SETITEMDATA,rv,(LPARAM)tag); + else + { + free(tag->name); + free(tag->value); + delete tag; + } + return rv; + + } + + virtual void OnUpdateRect(UINT sx,UINT sy) + {//WM_SIZE-ish + do_size_xy(IDC_LIST,&info_list); + } + + virtual BOOL DlgProc(UINT msg,WPARAM wp,LPARAM lp) + { + switch(msg) + { + case WM_DESTROY: + lb_clear(); + list=0; + break; + case WM_COMMAND: + switch(wp) + { + case IDOK: + case IDCANCEL: + SendMessage(GetParent(wnd),msg,wp,lp); + break; + } + break; +// case WM_INITDIALOG: +// return 1; + } + return 0; + } + + void lb_clear() + { + if (!list) return; + int num=(int)SendMessage(list,LB_GETCOUNT,0,0); + while(num>0) + { + TAGDESC * l=(TAGDESC*)SendMessage(list,LB_GETITEMDATA,0,0); + if (l) + { + free(l->name); + free(l->value); + delete l; + } + SendMessage(list,LB_DELETESTRING,0,0); + num--; + } + } + + virtual void SetTag(wchar_t * name,wchar_t * value) + { + TAGDESC * l=new TAGDESC; + l->name=_wcsdup(name); + l->value=_wcsdup(value); + lb_addstring(l); + } + +public: + virtual void Clear() + { + hidden.Clear(); + lb_clear(); + } + void UpdateRect(RECT &r) + { + SetWindowPos(wnd,0,r.left,r.top,r.right-r.left,r.bottom-r.top,SWP_NOZORDER|SWP_NOACTIVATE|SWP_SHOWWINDOW); + RECT z; + GetClientRect(wnd,&z); + OnUpdateRect(z.right-z.left,z.bottom-z.top); + } + + virtual void GetTags(OggTagData & tags) + { + if (!list) return; + int num=(int)SendMessage(list,LB_GETCOUNT,0,0); + int n; + for(n=0;n<num;n++) + { + TAGDESC * l=(TAGDESC*)SendMessage(list,LB_GETITEMDATA,n,0); + tags.AddTag(l->name,l->value); + } + TAG * t=hidden.tags; + while(t) + { + tags.AddTag(t->name,t->value); + t=t->next; + } + } + + void SetTags(OggTagData & tags,BOOL hidespec) + { + TAG * t=tags.tags; + while(t) + { + bool hide=0; + if (hidespec) + { + int n; + for(n=0;n<N_SPECIAL_FIELDS;n++) + { + if (!_wcsicmp(t->name,special_fields[n])) + { + hidden.AddTag(t->name,t->value); + hide=1;break; + } + } + } + if (!hide) SetTag(t->name,t->value); + t=t->next; + } + } +}; + +class InfoDlgPanel_adv : public InfoDlgPanel +{ +private: + virtual void OnUpdateRect(UINT sx,UINT sy) + { + InfoDlgPanel::OnUpdateRect(sx,sy); + } +public: + InfoDlgPanel_adv(HWND parent,HFONT foo) : InfoDlgPanel(IDD_INFO_PANEL_ADVANCED,parent,foo) + { + } +}; + +class InfoDlgPanel_simple : public InfoDlgPanel +{ +private: + RECT info_static_std,info_title,info_artist,info_album,info_track,info_genre,info_comment,info_static_track,info_static_tags; + wchar_t *tag_bk[N_STD_TAGZ]; + BOOL STFU; +protected: + virtual void OnUpdateRect(UINT sx,UINT sy) + { + do_size_x(IDC_STATIC_STD,&info_static_std); + do_size_x(IDC_TITLE,&info_title); + do_size_x(IDC_ARTIST,&info_artist); + do_size_x(IDC_ALBUM,&info_album); + do_align_x(IDC_TRACK,&info_track); + do_size_x(IDC_GENRE,&info_genre); + do_size_x(IDC_COMMENT,&info_comment); + do_align_x(IDC_STATIC_TRACK,&info_static_track); + do_size_xy(IDC_STATIC_TAGS,&info_static_tags); + InfoDlgPanel::OnUpdateRect(sx,sy); + } + virtual BOOL DlgProc(UINT msg,WPARAM wp,LPARAM lp) + { + switch(msg) + { + case WM_COMMAND: + if (!STFU && (HIWORD(wp)==EN_CHANGE || HIWORD(wp)==CBN_EDITCHANGE || HIWORD(wp)==CBN_SELCHANGE)) + { + UINT n; + for(n=0;n<N_STD_TAGZ;n++) + { + if (LOWORD(wp)==std_tagz[n].id) + { + if (tag_bk[n]) {free(tag_bk[n]);tag_bk[n]=0;} + break; + } + } + } + break; + } + return InfoDlgPanel::DlgProc(msg,wp,lp); + } +public: + virtual void Clear() + { + int n; + for(n=0;n<N_STD_TAGZ;n++) + { + if (tag_bk[n]) + { + free(tag_bk[n]); + tag_bk[n]=0; + } + SetDlgItemText(wnd,std_tagz[n].id,L""); + } + InfoDlgPanel::Clear(); + + } + ~InfoDlgPanel_simple() + { + UINT n; + for(n=0;n<N_STD_TAGZ;n++) + { + if (tag_bk[n]) free(tag_bk[n]); + } + } + InfoDlgPanel_simple(HWND parent,HFONT foo) : InfoDlgPanel(IDD_INFO_PANEL_SIMPLE,parent,foo) + { + STFU=0; + memset(tag_bk,0,sizeof(tag_bk)); + UINT n; + MakeComboEdit(IDC_GENRE,ES_READONLY|ES_AUTOHSCROLL|WS_VISIBLE); + for(n=0;n<N_STD_TAGZ;n++) + { + HWND w=GetDlgItem(wnd,std_tagz[n].id); + SendMessage(w,WM_SETFONT,(WPARAM)font,0); + SendMessage(w,EM_SETREADONLY,1,0); + } + + GetChildRect(IDC_STATIC_STD,info_static_std); + GetChildRect(IDC_TITLE,info_title); + GetChildRect(IDC_ARTIST,info_artist); + GetChildRect(IDC_ALBUM,info_album); + GetChildRect(IDC_TRACK,info_track); + GetChildRect(IDC_GENRE,info_genre); + GetChildRect(IDC_COMMENT,info_comment); + GetChildRect(IDC_STATIC_TRACK,info_static_track); + GetChildRect(IDC_STATIC_TAGS,info_static_tags); + + genres_read(GetDlgItem(wnd,IDC_GENRE), genres_file); + } + + virtual void GetTags(OggTagData & tags) + { + genres_write(GetDlgItem(wnd,IDC_GENRE),genres_file); + UINT n; + for(n=0;n<N_STD_TAGZ;n++) + { + if (tag_bk[n]) + { + tags.AddTag(std_tagz[n].name,tag_bk[n]); + } + else + { + StringW t; + t.s_GetWindowText(GetDlgItem(wnd,std_tagz[n].id)); + if (t.Length()>0) + { + tags.AddTag(std_tagz[n].name,t); + } + } + } + InfoDlgPanel::GetTags(tags); + } + virtual void SetTag(wchar_t * name,wchar_t * value) + { + STFU=1; + UINT n; + for(n=0;n<N_STD_TAGZ;n++) + { + if (tag_bk[n]) continue; + if (!_wcsicmp(name,std_tagz[n].name)) + { + tag_bk[n]=_wcsdup(value); + SetDlgItemTextWrap(wnd,std_tagz[n].id,value); + STFU=0; + return; + } + } + STFU=0; + InfoDlgPanel::SetTag(name,value); + } +}; + +char * rstrcpy(char* s1,char* s2) +{ + while(s2 && *s2) *(s1++)=*(s2++); + return s1; +} + +static void _inline print_misc(VorbisFile * _vf,int link,char * out,int len) +{ + OggVorbis_File * vf=&_vf->vf; + char* p=out, kbps_str[16] = {0}; + double t=ov_time_total(vf,link); + vorbis_info * vi=ov_info(vf,link); + vorbis_comment * vc=ov_comment(vf,link); + if (!vi || !vc) {WASABI_API_LNGSTRING_BUF(IDS_FILE_ERROR,out,512);return;} + + StringCchPrintfA(kbps_str, 16, " %s\r\n", WASABI_API_LNGSTRING(IDS_KBPS)); + + if (t>0) + { + p=rstrcpy(p,WASABI_API_LNGSTRING(IDS_LENGTH)); + int h=(int)(t/3600.0); + if (h>0) + { + uitoa(h,p); + while(p && *p) p++; + *(p++)=':'; + } + int m=(int)(t/60.0)%60; +// if (m>0 || h>0) + { + sprintf(p,h>0 ? "%02u" : "%u",m); + while(p && *p) p++; + *(p++)=':'; + } + int s=(int)t%60; + //sprintf(p,(m>0 || h>0) ? "%02u" : "%u seconds",s); + sprintf(p,"%02d",s); + while(p && *p) p++; + p=rstrcpy(p,"\r\n"); + +// uitoa((int)(t*1000.0),p); +// while(p && *p) p++; +// p=rstrcpy(p," ms"); + UINT fs=_vf->FileSize(); + if (fs>0) + { + if (vf->links==1) + { + p=rstrcpy(p,WASABI_API_LNGSTRING(IDS_AVERAGE_BITRATE)); + uitoa((int)(((double)fs)/(t*125.0)),p); + while(p && *p) p++; + p=rstrcpy(p,kbps_str); + } + if (fs>0) + { + p=rstrcpy(p,WASABI_API_LNGSTRING(IDS_FILE_SIZE)); + + UINT fs1=fs/1000000; + UINT fs2=(fs/1000)%1000; + UINT fs3=fs%1000; + if (fs1) sprintf(p,"%u%03u%03u %s\r\n",fs1,fs2,fs3,WASABI_API_LNGSTRING(IDS_BYTES)); + else if (fs2) sprintf(p,"%u%03u %s\r\n",fs2,fs3,WASABI_API_LNGSTRING(IDS_BYTES)); + else sprintf(p,"%u %s\r\n",fs3,WASABI_API_LNGSTRING(IDS_BYTES)); + while(p && *p) p++; + } + } + } + if (vi->bitrate_nominal>0) + { + p=rstrcpy(p,WASABI_API_LNGSTRING(IDS_NOMINAL_BITRATE)); + uitoa(vi->bitrate_nominal/1000,p); + while(p && *p) p++; + p=rstrcpy(p,kbps_str); + } + if (vi->bitrate_lower>0) + { + p=rstrcpy(p,WASABI_API_LNGSTRING(IDS_MIN_BITRATE)); + uitoa(vi->bitrate_lower/1000,p); + while(p && *p) p++; + p=rstrcpy(p,kbps_str); + } + if (vi->bitrate_upper>0) + { + p=rstrcpy(p,WASABI_API_LNGSTRING(IDS_MAX_BITRATE)); + uitoa(vi->bitrate_upper/1000,p); + while(p && *p) p++; + p=rstrcpy(p,kbps_str); + } + + char tmp[32] = {0}, tmp2[32] = {0}, tmp3[32] = {0}, tmp4[32] = {0}, tmp5[32] = {0}, tmp6[8] = {0}; + StringCchPrintfA(p,len, "%s : %u\r\n" + "%s : %u %s\r\n" + "%s : %u\r\n" + "%s : %u\r\n" + "%s : \r\n%s", + WASABI_API_LNGSTRING_BUF(IDS_CHANNELS,tmp,32),vi->channels, + WASABI_API_LNGSTRING_BUF(IDS_SAMPLING_RATE,tmp2,32),vi->rate,WASABI_API_LNGSTRING_BUF(IDS_HZ,tmp6,8), + WASABI_API_LNGSTRING_BUF(IDS_SERIAL_NUMBER,tmp3,32),ov_serialnumber(vf,link), + WASABI_API_LNGSTRING_BUF(IDS_VERSION,tmp4,32),vi->version, + WASABI_API_LNGSTRING_BUF(IDS_VENDOR,tmp5,32),vc->vendor); +} + +class InfoDlg : public DlgBase +{ +private: + InfoDlg * next; + static InfoDlg* Instances; + OggTagData **tags; + char ** infos; + int n_streams,cur_stream; + StringW url; + HFONT ui_font; + BOOL is_adv; + InfoDlgPanel* panel; + RECT info_static_misc,info_misc,info_url,info_cancel,info_mode,info_static_cs,info_cs_next,info_cs_prev,info_hidespec; + + void calc_panel_rect(RECT &r) + { + RECT cr,cr1,cr2; + GetClientRect(wnd,&cr); + GetChildRect(IDC_STATIC_MISC,cr1); + GetChildRect(IDC_URL,cr2); + r.left=0; + r.top=cr2.bottom+1; + r.right=cr1.left-1; + r.bottom=cr.bottom; + } + void do_size() + { + if (panel) + { + RECT r; + calc_panel_rect(r); + panel->UpdateRect(r); + } + } + void do_panel(BOOL mode,int d_stream) + { + //if (panel && is_adv==mode && !d_stream) return; + if (panel) + { + if (mode!=is_adv) + { + delete panel; + panel=0; + } + else + { + panel->Clear(); + } + } + cur_stream+=d_stream; + if (cur_stream<0) cur_stream=0; + else if (cur_stream>=n_streams) cur_stream=n_streams-1; + is_adv=mode; + if (!panel) + { + panel = mode ? (InfoDlgPanel*) new InfoDlgPanel_adv(wnd,ui_font) : (InfoDlgPanel*) new InfoDlgPanel_simple(wnd,ui_font); + do_size(); + } + if (panel) + { + panel->SetTags(*tags[cur_stream],(BOOL)SendDlgItemMessage(wnd,IDC_HIDE_SPEC,BM_GETCHECK,0,0)); + } + SetDlgItemText(wnd,IDC_MODE_TOGGLE,WASABI_API_LNGSTRINGW((is_adv ? IDS_TO_SIMPLE_MODE : IDS_TO_ADVANCED_MODE))); + EnableWindow(GetDlgItem(wnd,IDC_PREV_STREAM),cur_stream>0); + EnableWindow(GetDlgItem(wnd,IDC_NEXT_STREAM),cur_stream<n_streams-1); + // TODO + SetDlgItemTextA(wnd,IDC_MISC,infos[cur_stream]); + } +protected: + virtual BOOL DlgProc(UINT msg,WPARAM wp,LPARAM lp) + { + switch(msg) + { + case WM_INITDIALOG: + if (n_streams<=1) + { + ShowWindow(GetDlgItem(wnd,IDC_STATIC_CS),SW_HIDE); + ShowWindow(GetDlgItem(wnd,IDC_PREV_STREAM),SW_HIDE); + ShowWindow(GetDlgItem(wnd,IDC_NEXT_STREAM),SW_HIDE); + } + + SendDlgItemMessage(wnd,IDC_HIDE_SPEC,BM_SETCHECK,cfg_hide_special_fields,0); + + do_panel(cfg_adv_info,0); + url.s_SetDlgItemText(wnd,IDC_URL); + GetChildRect(IDC_URL,info_url); + GetChildRect(IDC_STATIC_MISC,info_static_misc); + GetChildRect(IDC_MISC,info_misc); + GetChildRect(IDCANCEL,info_cancel); + GetChildRect(IDC_MODE_TOGGLE,info_mode); + GetChildRect(IDC_STATIC_CS,info_static_cs); + GetChildRect(IDC_NEXT_STREAM,info_cs_next); + GetChildRect(IDC_PREV_STREAM,info_cs_prev); + GetChildRect(IDC_HIDE_SPEC,info_hidespec); + + if (cfg_remember_infosize && cfg_infobox_sx>0 && cfg_infobox_sy>0) + { + int max_x=GetSystemMetrics(SM_CXSCREEN),max_y=GetSystemMetrics(SM_CYSCREEN); + if (cfg_infobox_x<0) cfg_infobox_x=0; + else if (cfg_infobox_x+cfg_infobox_sx>max_x) cfg_infobox_x=max_x-cfg_infobox_sx; + if (cfg_infobox_y<0) cfg_infobox_y=0; + else if (cfg_infobox_y+cfg_infobox_sy>max_y) cfg_infobox_y=max_y-cfg_infobox_sy; + + SetWindowPos(wnd,0,cfg_infobox_x,cfg_infobox_y,cfg_infobox_sx,cfg_infobox_sy,SWP_NOZORDER|SWP_NOACTIVATE); + } + + StringPrintfW(WASABI_API_LNGSTRINGW(IDS_OGG_VORBIS_INFO),(const WCHAR*)StringF2T_W((const WCHAR*)url)).s_SetWindowText(wnd); + return 1; + case WM_SIZE: + { + UINT sx=LOWORD(lp),sy=HIWORD(lp); + do_size_x(IDC_URL,&info_url); + do_align_x(IDC_STATIC_MISC,&info_static_misc); + do_align_x(IDC_MISC,&info_misc); + do_align_xy(IDCANCEL,&info_cancel); + do_align_xy(IDC_MODE_TOGGLE,&info_mode); + do_align_xy(IDC_STATIC_CS,&info_static_cs); + do_align_xy(IDC_PREV_STREAM,&info_cs_prev); + do_align_xy(IDC_NEXT_STREAM,&info_cs_next); + do_align_xy(IDC_HIDE_SPEC,&info_hidespec); + } + //RedrawWindow(wnd,0,0,RDW_INVALIDATE); + do_size(); + break; + case WM_SIZING: + do_sizing((UINT)wp,(RECT*)lp); + break; + case WM_COMMAND: + switch(wp) + { + case IDCANCEL: + endDialog(0); + break; + case IDC_MODE_TOGGLE: + do_panel(!is_adv,0); + break; + case IDC_PREV_STREAM: + do_panel(is_adv,-1); + break; + case IDC_NEXT_STREAM: + do_panel(is_adv,1); + break; + case IDC_HIDE_SPEC: + cfg_hide_special_fields=(int)SendMessage((HWND)lp,BM_GETCHECK,0,0); + do_panel(is_adv,0); + break; + } + break; + case WM_CLOSE: + endDialog(0); + break; + case WM_DESTROY: + if (!is_modeless)//fucko close + { + modal_ex_quit=1; + } + + { + RECT r; + GetWindowRect(wnd,&r); + cfg_infobox_sx=r.right-r.left; + cfg_infobox_sy=r.bottom-r.top; + cfg_infobox_x=r.left; + cfg_infobox_y=r.top; + } + break; + } + return 0; + } + virtual void myProcessMessage(MSG * msg) + { + if (!panel || !panel->isDialogMessage(msg)) + { + DlgBase::myProcessMessage(msg); + } + } + +public: + InfoDlg(VorbisFile * _vf,const wchar_t * _url) + : url(_url), is_adv(FALSE) + { + OggVorbis_File * vf=&_vf->vf; + n_streams=vf->links; + cur_stream=vf->current_link; + tags=(OggTagData**)malloc(n_streams*sizeof(void*)); + int n; + for(n=0;n<n_streams;n++) tags[n]=new OggTagData(ov_comment(vf,n)); + infos=(char**)malloc(sizeof(void*)*n_streams); + for(n=0;n<n_streams;n++) + { + int l = 512+(int)strlen(vf->vc->vendor); + infos[n]=(char*)malloc(l); + print_misc(_vf,n,infos[n],l); + } + + ui_font=CreateFontIndirect(&cfg_font.data); + panel=0; + next=0; + } + ~InfoDlg() + { + if (ui_font) DeleteObject((HGDIOBJ)ui_font); + cfg_adv_info=is_adv; + if (tags) + { + int n; + for(n=0;n<n_streams;n++) + delete tags[n]; + free(tags); + } + if (infos) + { + int n; + for(n=0;n<n_streams;n++) free(infos[n]); + free(infos); + } + + InfoDlg ** pp=&Instances,*p=Instances; + while(p) + { + if (p==this) + { + *pp=next; + break; + } + else {pp=&p->next;p=*pp;} + } + } + void Run(HWND parent,bool modeless) + { + next=Instances; + Instances=this;//HACK - prevent crash on shutdown (used to be only for modeless) + + if (modeless) + { + myCreateDialog(IDD_INFO_DLG_NEW,parent); + } + else myDialogBoxEx(IDD_INFO_DLG_NEW,parent); + } + +friend int RunInfoDlg(const in_char * url,HWND parent); +}; + +int RunInfoDlg(const in_char * url,HWND parent) +{ + static bool in_modal; + if (in_modal) return 1; + else in_modal=1; + VorbisFile * vf; + bool vf_global=0; + int ret=0; + StringW _url; + _url.AddString(url); + + { + InfoDlg * p=InfoDlg::Instances; + while(p) + { + if (!_wcsicmp(p->url,_url)) + { + ShowWindow(p->wnd,SW_SHOW); + SetActiveWindow(p->wnd); + return 0; + } + p=p->next; + } + } + + EnterCriticalSection(&sync); + if ((url==cur_file || !_wcsicmp(url,cur_file)) && theFile) {vf=theFile;vf_global=1;} + else + { + LeaveCriticalSection(&sync); + vf=VorbisFile::Create(url,1); + if (!vf) + { + in_modal=0; + return 0; + } + } + { + InfoDlg d(vf,_url); + if (vf_global) LeaveCriticalSection(&sync); + else delete vf; + d.Run(parent,0); + ret = !d.modal_ex_quit_val; + } + in_modal=0; + return ret; +} + +InfoDlg* InfoDlg::Instances=0; +/* end crappy PP dialog */ + +bool VorbisTagToWinampTag(wchar_t * tag, int len) +{ +#define TAG_ALIAS(b,a) if(!_wcsicmp(L ## a, tag)) { lstrcpynW(tag, L ## b, len); return true; } + TAG_ALIAS("title", "TITLE"); + TAG_ALIAS("artist", "ARTIST"); + TAG_ALIAS("album", "ALBUM"); + TAG_ALIAS("genre", "GENRE"); + TAG_ALIAS("comment", "COMMENT"); + TAG_ALIAS("year", "DATE"); + TAG_ALIAS("track", "TRACKNUMBER"); + TAG_ALIAS("albumartist", "ALBUMARTIST"); + TAG_ALIAS("composer", "COMPOSER"); + TAG_ALIAS("disc", "DISCNUMBER"); + TAG_ALIAS("publisher", "PUBLISHER"); + TAG_ALIAS("conductor", "CONDUCTOR"); + TAG_ALIAS("bpm", "BPM"); + return false; +#undef TAG_ALIAS +} + +bool WinampTagToVorbisTag(wchar_t * tag, int len) +{ +#define TAG_ALIAS(a,b) if(!_wcsicmp(L ## a, tag)) { lstrcpynW(tag, L ## b, len); return true; } + TAG_ALIAS("title", "TITLE"); + TAG_ALIAS("artist", "ARTIST"); + TAG_ALIAS("album", "ALBUM"); + TAG_ALIAS("genre", "GENRE"); + TAG_ALIAS("comment", "COMMENT"); + TAG_ALIAS("year", "DATE"); + TAG_ALIAS("track", "TRACKNUMBER"); + TAG_ALIAS("albumartist", "ALBUMARTIST"); + TAG_ALIAS("composer", "COMPOSER"); + TAG_ALIAS("disc", "DISCNUMBER"); + TAG_ALIAS("publisher", "PUBLISHER"); + TAG_ALIAS("conductor", "CONDUCTOR"); + TAG_ALIAS("bpm", "BPM"); + return false; +#undef TAG_ALIAS +} + +static INT_PTR CALLBACK ChildProc_Advanced(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) { + static int sel=-1; + static int ismychange=0; + switch(msg) + { + case WM_NOTIFYFORMAT: + return NFR_UNICODE; + case WM_INITDIALOG: + { + #define ListView_InsertColumnW(hwnd, iCol, pcol) \ + (int)SNDMSG((hwnd), LVM_INSERTCOLUMNW, (WPARAM)(int)(iCol), (LPARAM)(const LV_COLUMNW *)(pcol)) + SetWindowLongPtr(hwndDlg,GWLP_USERDATA,lParam); + sel=-1; + HWND hwndlist = GetDlgItem(hwndDlg,IDC_LIST); + ListView_SetExtendedListViewStyle(hwndlist, LVS_EX_FULLROWSELECT); + LVCOLUMNW lvc = {0, }; + lvc.mask = LVCF_TEXT|LVCF_WIDTH; + lvc.pszText = WASABI_API_LNGSTRINGW(IDS_NAME); + lvc.cx = 82; + ListView_InsertColumnW(hwndlist, 0, &lvc); + lvc.pszText = WASABI_API_LNGSTRINGW(IDS_VALUE); + lvc.cx = 160; + ListView_InsertColumnW(hwndlist, 1, &lvc); + + Info *info = (Info *)lParam; + int n = info->GetNumMetadataItems(); + for(int i=0; i<n; i++) { + wchar_t key[512] = {0}; + wchar_t value[2048] = {0}; + info->EnumMetadata(i,key,512,value,2048); + if(value[0] && key[0]) { + LVITEMW lvi={LVIF_TEXT,i,0}; + lvi.pszText = key; + SendMessage(hwndlist,LVM_INSERTITEMW,0,(LPARAM)&lvi); + lvi.iSubItem=1; + lvi.pszText = (wchar_t*)value; + SendMessage(hwndlist,LVM_SETITEMW,0,(LPARAM)&lvi); + } + } + ListView_SetColumnWidth(hwndlist,0,(n?LVSCW_AUTOSIZE:LVSCW_AUTOSIZE_USEHEADER)); + ListView_SetColumnWidth(hwndlist,1,(n?LVSCW_AUTOSIZE:LVSCW_AUTOSIZE_USEHEADER)); + + SetDlgItemTextW(hwndDlg,IDC_NAME,L""); + SetDlgItemTextW(hwndDlg,IDC_VALUE,L""); + EnableWindow(GetDlgItem(hwndDlg,IDC_NAME),FALSE); + EnableWindow(GetDlgItem(hwndDlg,IDC_VALUE),FALSE); + EnableWindow(GetDlgItem(hwndDlg,IDC_BUTTON_DEL),FALSE); + } + break; + case WM_DESTROY: + { + HWND hwndlist = GetDlgItem(hwndDlg,IDC_LIST); + ListView_DeleteAllItems(hwndlist); + while(ListView_DeleteColumn(hwndlist,0)); + Info * info = (Info*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA); + delete info; + } + break; + case WM_USER: + if(wParam && lParam && !ismychange) + { + wchar_t * value = (wchar_t*)lParam; + wchar_t tag[100] = {0}; + lstrcpynW(tag,(wchar_t*)wParam,100); + WinampTagToVorbisTag(tag,100); + Info *info = (Info *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + if(!*value) + { + info->RemoveMetadata(tag); + if(!_wcsicmp(L"ALBUMARTIST",tag)) + { + // need to remove these two, also, or else it's gonna look like delete doesn't work + // if the file was tagged using these alternate fields + info->RemoveMetadata(L"ALBUM ARTIST"); + info->RemoveMetadata(L"ENSEMBLE"); + } + if(!_wcsicmp(L"PUBLISHER",tag)) + { + // need to remove this also, or else it's gonna look like delete doesn't work + // if the file was tagged using this alternate field + info->RemoveMetadata(L"ORGANIZATION"); + } + if(!_wcsicmp(L"DATE",tag)) + { + // need to remove this also, or else it's gonna look like delete doesn't work + // if the file was tagged using this alternate field + info->RemoveMetadata(L"YEAR"); + } + if(!_wcsicmp(L"TRACKNUMBER",tag)) + { + // need to remove this also, or else it's gonna look like delete doesn't work + // if the file was tagged using this alternate field + info->RemoveMetadata(L"TRACK"); + } + } + else + { + info->SetMetadata(tag,value); + } + + HWND hlist = GetDlgItem(hwndDlg,IDC_LIST); + int n = ListView_GetItemCount(hlist); + for(int i=0; i<n; i++) + { + wchar_t key[100]=L""; + LVITEMW lvi={LVIF_TEXT,i,0}; + lvi.pszText=key; + lvi.cchTextMax=100; + SendMessage(hlist,LVM_GETITEMW,0,(LPARAM)&lvi); + if(!_wcsicmp(key,tag)) + { + lvi.iSubItem = 1; + lvi.pszText = value; + SendMessage(hlist,LVM_SETITEMW,0,(LPARAM)&lvi); + if(!*value) + ListView_DeleteItem(hlist,i); + else if(ListView_GetItemState(hlist,i,LVIS_SELECTED)) + SetDlgItemTextW(hwndDlg,IDC_VALUE,value); + return 0; + } + } + // bew hew, not found + LVITEMW lvi={0,0x7FFFFFF0,0}; + n = (int)SendMessage(hlist,LVM_INSERTITEMW,0,(LPARAM)&lvi); + lvi.mask = LVIF_TEXT; + lvi.iItem = n; + lvi.iSubItem = 0; + lvi.pszText = tag; + SendMessage(hlist,LVM_SETITEMW,0,(LPARAM)&lvi); + lvi.iSubItem = 1; + lvi.pszText = value; + SendMessage(hlist,LVM_SETITEMW,0,(LPARAM)&lvi); + } + break; + case WM_NOTIFY: + { + LPNMHDR l=(LPNMHDR)lParam; + if(l->idFrom==IDC_LIST && l->code == LVN_KEYDOWN) { + if((((LPNMLVKEYDOWN)l)->wVKey) == VK_DELETE){ + int selitem = ListView_GetNextItem(l->hwndFrom,-1,LVNI_SELECTED|LVNI_FOCUSED); + if(selitem != -1) + SendMessage(hwndDlg,WM_COMMAND,MAKEWPARAM(IDC_BUTTON_DEL,BN_CLICKED),(LPARAM)GetDlgItem(hwndDlg,IDC_BUTTON_DEL)); + } + } + else if(l->idFrom==IDC_LIST && l->code == LVN_ITEMCHANGED) { + LPNMLISTVIEW lv=(LPNMLISTVIEW)lParam; + if(lv->uNewState & LVIS_SELECTED) { + int n = lv->iItem; + LVITEMW lvi={LVIF_TEXT,lv->iItem,0}; + wchar_t key[100] = {0}; + wchar_t value[1024] = {0}; + lvi.pszText=key; + lvi.cchTextMax=100; + SendMessage(l->hwndFrom,LVM_GETITEMW,0,(LPARAM)&lvi); + lvi.pszText=value; + lvi.cchTextMax=1024; + lvi.iSubItem=1; + SendMessage(l->hwndFrom,LVM_GETITEMW,0,(LPARAM)&lvi); + SetDlgItemTextW(hwndDlg,IDC_NAME,key); + SetDlgItemTextW(hwndDlg,IDC_VALUE,value); + sel = n; + EnableWindow(GetDlgItem(hwndDlg,IDC_NAME),TRUE); + EnableWindow(GetDlgItem(hwndDlg,IDC_VALUE),TRUE); + EnableWindow(GetDlgItem(hwndDlg,IDC_BUTTON_DEL),TRUE); + } + if(lv->uOldState & LVIS_SELECTED) { + sel = -1; + SetDlgItemTextW(hwndDlg,IDC_NAME,L""); + SetDlgItemTextW(hwndDlg,IDC_VALUE,L""); + EnableWindow(GetDlgItem(hwndDlg,IDC_NAME),FALSE); + EnableWindow(GetDlgItem(hwndDlg,IDC_VALUE),FALSE); + EnableWindow(GetDlgItem(hwndDlg,IDC_BUTTON_DEL),FALSE); + } + } + } + break; + case WM_COMMAND: + switch(LOWORD(wParam)) { + case IDOK: + { + Info * info = (Info*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA); + if (!info->Save()) + { + MessageBox(hwndDlg, + L"Cannot save metadata: Error writing file or file is read-only.", + L"Error saving metadata.", + MB_OK); + } + } + break; + case IDC_NAME: + case IDC_VALUE: + if(HIWORD(wParam) == EN_CHANGE && sel>=0) { + wchar_t key[100] = {0}; + wchar_t value[1024] = {0}; + LVITEMW lvi={LVIF_TEXT,sel,0}; + GetDlgItemTextW(hwndDlg,IDC_NAME,key,100); + GetDlgItemTextW(hwndDlg,IDC_VALUE,value,1024); + lvi.pszText=key; + lvi.cchTextMax=100; + SendMessage(GetDlgItem(hwndDlg,IDC_LIST),LVM_SETITEMW,0,(LPARAM)&lvi); + lvi.pszText=value; + lvi.cchTextMax=1024; + lvi.iSubItem=1; + SendMessage(GetDlgItem(hwndDlg,IDC_LIST),LVM_SETITEMW,0,(LPARAM)&lvi); + VorbisTagToWinampTag(key,100); + ismychange=1; + SendMessage(GetParent(hwndDlg),WM_USER,(WPARAM)key,(WPARAM)value); + ismychange=0; + } + else if(HIWORD(wParam) == EN_KILLFOCUS && sel>=0) { + wchar_t key[100] = {0}; + wchar_t value[1024] = {0}; + GetDlgItemTextW(hwndDlg,IDC_NAME,key,100); + GetDlgItemTextW(hwndDlg,IDC_VALUE,value,1024); + Info *info = (Info *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + wchar_t oldkey[100]=L""; + bool newitem=true; + if(sel < info->GetNumMetadataItems()) { + info->EnumMetadata(sel,oldkey,100,0,0); + newitem=false; + } + + if(!newitem && wcscmp(oldkey,key)) { // key changed + info->SetTag(sel,key); + } else { + info->SetMetadata(key,value); + } + VorbisTagToWinampTag(key,100); + ismychange=1; + SendMessage(GetParent(hwndDlg),WM_USER,(WPARAM)key,(WPARAM)value); + ismychange=0; + } + break; + case IDC_BUTTON_DEL: + if(sel >= 0) { + wchar_t tag[100] = {0}; + GetDlgItemTextW(hwndDlg,IDC_NAME,tag,100); + SetDlgItemTextW(hwndDlg,IDC_NAME,L""); + SetDlgItemTextW(hwndDlg,IDC_VALUE,L""); + EnableWindow(GetDlgItem(hwndDlg,IDC_NAME),FALSE); + EnableWindow(GetDlgItem(hwndDlg,IDC_VALUE),FALSE); + EnableWindow(GetDlgItem(hwndDlg,IDC_BUTTON_DEL),FALSE); + Info *info = (Info *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + if(sel < info->GetNumMetadataItems()) + info->RemoveMetadata(sel); + ListView_DeleteItem(GetDlgItem(hwndDlg,IDC_LIST),sel); + sel=-1; + VorbisTagToWinampTag(tag,100); + ismychange=1; + SendMessage(GetParent(hwndDlg),WM_USER,(WPARAM)tag,(WPARAM)L""); + ismychange=0; + } + break; + case IDC_BUTTON_DELALL: + ListView_DeleteAllItems(GetDlgItem(hwndDlg,IDC_LIST)); + SetDlgItemTextW(hwndDlg,IDC_NAME,L""); + SetDlgItemTextW(hwndDlg,IDC_VALUE,L""); + EnableWindow(GetDlgItem(hwndDlg,IDC_NAME),FALSE); + EnableWindow(GetDlgItem(hwndDlg,IDC_VALUE),FALSE); + EnableWindow(GetDlgItem(hwndDlg,IDC_BUTTON_DEL),FALSE); + sel=-1; + { + Info *info = (Info *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + int n = info->GetNumMetadataItems(); + while(n>0) { + --n; + wchar_t tag[100] = {0}; + info->EnumMetadata(n,tag,100,0,0); + VorbisTagToWinampTag(tag,100); + ismychange=1; + SendMessage(GetParent(hwndDlg),WM_USER,(WPARAM)tag,(WPARAM)L""); + ismychange=0; + info->RemoveMetadata(n); + } + } + break; + case IDC_BUTTON_ADD: + { + HWND hwndlist = GetDlgItem(hwndDlg,IDC_LIST); + LVITEMW lvi={0,0x7FFFFFF0,0}; + int n = (int)SendMessage(hwndlist,LVM_INSERTITEMW,0,(LPARAM)&lvi); + ListView_SetItemState(hwndlist,n,LVIS_SELECTED,LVIS_SELECTED); + } + break; + } + break; + } + return 0; +} + +extern "C" +{ + // return 1 if you want winamp to show it's own file info dialogue, 0 if you want to show your own (via In_Module.InfoBox) + // if returning 1, remember to implement winampGetExtendedFileInfo("formatinformation")! + __declspec(dllexport) int winampUseUnifiedFileInfoDlg(const wchar_t * fn) + { + if (PathIsURLW(fn)) + return 0; + return 1; + } + + // should return a child window of 513x271 pixels (341x164 in msvc dlg units), or return NULL for no tab. + // Fill in name (a buffer of namelen characters), this is the title of the tab (defaults to "Advanced"). + // filename will be valid for the life of your window. n is the tab number. This function will first be + // called with n == 0, then n == 1 and so on until you return NULL (so you can add as many tabs as you like). + // The window you return will recieve WM_COMMAND, IDOK/IDCANCEL messages when the user clicks OK or Cancel. + // when the user edits a field which is duplicated in another pane, do a SendMessage(GetParent(hwnd),WM_USER,(WPARAM)L"fieldname",(LPARAM)L"newvalue"); + // this will be broadcast to all panes (including yours) as a WM_USER. + __declspec(dllexport) HWND winampAddUnifiedFileInfoPane(int n, const wchar_t * filename, HWND parent, wchar_t *name, size_t namelen) + { + if(n == 0) { // add first pane + SetPropW(parent,L"INBUILT_NOWRITEINFO", (HANDLE)1); + Info *info = new Info(filename); + if(info->Error()) + { + delete info; + return NULL; + } + return WASABI_API_CREATEDIALOGPARAMW(IDD_INFO,parent,ChildProc_Advanced,(LPARAM)info); + } + return NULL; + } +};
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/localfile.cpp b/Src/Plugins/Input/in_vorbis/localfile.cpp new file mode 100644 index 00000000..7f163f7d --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/localfile.cpp @@ -0,0 +1,260 @@ +#include "main.h" +#include "../nu/AutoChar.h" + +extern CfgInt cfg_fullbuf; + +int VorbisFile::_f_close(void *) {return 0;} + +int VorbisFile::_f_seek(void* rs,__int64 offset,int whence) +{ + return ((VorbisFile*)rs)->f_seek(offset,whence); +} + +size_t VorbisFile::_f_read(void* ptr,size_t size,size_t nmemb,void * rs) +{ + return ((VorbisFile*)rs)->f_read((UINT)(size*nmemb),ptr); +} + +long VorbisFile::_f_tell(void* rs) +{ + return ((VorbisFile*)rs)->f_tell(); +} + +ov_callbacks VorbisFile::oc={_f_read,_f_seek,_f_close,_f_tell}; + +static __int64 Seek64(HANDLE hf, __int64 distance, DWORD MoveMethod) +{ + LARGE_INTEGER li; + + li.QuadPart = distance; + + li.LowPart = SetFilePointer (hf, li.LowPart, &li.HighPart, MoveMethod); + + if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) + { + li.QuadPart = -1; + } + + return li.QuadPart; +} + +static __int64 FileSize64(HANDLE file) +{ + LARGE_INTEGER position; + position.QuadPart=0; + position.LowPart = GetFileSize(file, (LPDWORD)&position.HighPart); + + if (position.LowPart == INVALID_FILE_SIZE && GetLastError() != NO_ERROR) + return INVALID_FILE_SIZE; + else + return position.QuadPart; +} + +class VorbisFile_Local : public VorbisFile +{ +private: + HANDLE hFile; +protected: + int f_seek(__int64 offset,int whence) + { + if(whence==SEEK_SET) offset+=baseoffs; + if (Seek64(hFile,offset,whence) != INVALID_SET_FILE_POINTER) return 0; + else return -1; + } + + size_t f_read(UINT siz,void * ptr) + { + DWORD bw=0; + ReadFile(hFile,ptr,siz,&bw,0); + return bw; + } + + UINT f_tell() + { + return (UINT)(SetFilePointer(hFile,0,0,FILE_CURRENT)-baseoffs); + } + + UINT FileSize() + { + return (UINT)(FileSize64(hFile)-baseoffs); + } + +public: + virtual int GetType() {return TYPE_LOCAL;} + VorbisFile_Local(HANDLE f,const wchar_t * u,bool is_info) : VorbisFile(u,is_info) {hFile=f;} + ~VorbisFile_Local() {CloseHandle(hFile);} +}; + +class VorbisFile_Mem : public VorbisFile +{ + BYTE * block; + UINT size,ptr; +protected: + int f_seek(__int64 offset,int whence) + { + switch(whence) + { + case SEEK_SET: + ptr=(UINT)(offset+baseoffs); + break; + case SEEK_CUR: + ptr+=(UINT)offset; + break; + case SEEK_END: + ptr=size+whence; + break; + } + if (ptr<=size) return 0; + else {ptr=size;return -1;} + } + + size_t f_read(UINT siz,void * out) + { + UINT d=size-ptr; + if (d>siz) d=siz; + memcpy(out,block+ptr,d); + ptr+=d; + return d; + } + + UINT f_tell() + { + return (UINT)(ptr-baseoffs); + } + + UINT FileSize() + { + return (UINT)(size-baseoffs); + } + +public: + virtual int GetType() {return TYPE_LOCAL;} + + VorbisFile_Mem(HANDLE f,const wchar_t * u,bool is_info) : VorbisFile(u,is_info) + { + size=GetFileSize(f,0); + ptr=0; + block=(BYTE*)malloc(size); + DWORD br = 0; + ReadFile(f,block,size,&br,0); + CloseHandle(f); + } + + ~VorbisFile_Mem() {free(block);} +}; + +VorbisFile * VorbisFile::Create(const wchar_t *url, bool is_info) +{ + VorbisFile * r; + if (PathIsURLW(url)) + { + if (is_info) return 0; + r=Create_HTTP(AutoChar(url),is_info); + } + else + { + __int64 baseoffs=0; + HANDLE f=CreateFileW(url,GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,0,OPEN_EXISTING,0,0); + if (f==INVALID_HANDLE_VALUE) return 0; + { + DWORD dw = 0, br = 0; + ReadFile(f,&dw,4,&br,0); + if(br==4 && dw=='SggO') + { + SetFilePointer(f,0,0,FILE_BEGIN); + } + else if(br==4 && dw=='FFIR') + { + //RIFF file + DWORD wavhdr = 0, nb = 0; + SetFilePointer(f,4,0,FILE_CURRENT); + ReadFile(f,&wavhdr,4,&nb,0); + if(nb!=4 || wavhdr!='EVAW') + { + goto abort; + } + + //find data starting point + char tmp[1024] = {0}; + ReadFile(f,&tmp,1024,&nb,0); + for(int i=0;i<1020;i++) + if(tmp[i]=='d'&&tmp[i+1]=='a'&&tmp[i+2]=='t'&&tmp[i+3]=='a') + { + baseoffs=i+12+8; + Seek64(f, baseoffs, FILE_BEGIN); + } + + if(!baseoffs) goto abort; + } + else + { + abort: + CloseHandle(f); + return 0; + } + } + + r=cfg_fullbuf ? (VorbisFile*)new VorbisFile_Mem(f,url,is_info) : (VorbisFile*)new VorbisFile_Local(f,url,is_info); + r->setBaseOffset(baseoffs); + } + if (r && !r->init()) + { + delete r; + r=0; + } + return r; +} + +bool VorbisFile::init() +{ + if (ov_open_callbacks(this,&vf,0,0,oc)) return 0; + //TODO bitrate + UINT siz=FileSize(); + double len=Length(); + if (siz>0 && len>0) + { + UINT divisor = (UINT)(len*125.0); + if (divisor) + avg_kbps=siz/divisor; + } + + post_init(); + return 1; +} + +int is_http(const char* url) +{ + return (!_strnicmp(url,"http://",7) || !_strnicmp(url,"https://",8)); +} + +void VorbisFile::set_meta(const vorbis_comment * vc,int links) +{ + if (links == vf.links) + { + int n; + for(n=0;n<links;n++) + { + vorbis_comment_clear(vf.vc+n); + /* + extern void vorbis_comment_init(vorbis_comment *vc); + extern void vorbis_comment_add(vorbis_comment *vc, char *comment); + extern void vorbis_comment_add_tag(vorbis_comment *vc,char *tag, char *contents); + extern char *vorbis_comment_query(vorbis_comment *vc, char *tag, int count); + extern int vorbis_comment_query_count(vorbis_comment *vc, char *tag); + extern void vorbis_comment_clear(vorbis_comment *vc); + */ + } + _ogg_free(vf.vc); + vf.vc = (vorbis_comment*) _ogg_calloc(links,sizeof(vorbis_comment)); + for(n=0;n<links;n++) + { + vorbis_comment_init(vf.vc+n); + int c; + for(c=0;c<vc[n].comments;c++) + { + vorbis_comment_add(vf.vc+n,vc[n].user_comments[c]); + } + vf.vc[n].vendor = _strdup(vc[n].vendor); + } + } +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/main.h b/Src/Plugins/Input/in_vorbis/main.h new file mode 100644 index 00000000..79c09dae --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/main.h @@ -0,0 +1,220 @@ +#ifndef IN_VORBIS_MAIN_H +#define IN_VORBIS_MAIN_H + +#define WINSOCK_API_LINKAGE + +#ifndef STRICT +#define STRICT +#endif + +#include <windows.h> + +extern int (*warand)(); +extern float (*warandf)(); + +inline void * z_malloc(int x) +{ + void* foo=malloc(x); + if (foo) memset(foo,0,x); + return foo; +} +#include <shlwapi.h> +#include <malloc.h> +#define uitoa(x,y) _itoa(x,y,10) +#define atoui atoi + +#include <vorbis\vorbisfile.h> +#include "c_string.h" +#include "../Winamp/in2.h" + +extern In_Module mod; + +#include "resource.h" + +#define VER L"1.79" +#define _NAME "Nullsoft Vorbis Decoder" + +extern "C" +{ + extern const char *INI_FILE; + extern const wchar_t *INI_DIRECTORY; +} +class CfgVar +{ +private: + String name; + CfgVar * next; + static CfgVar * list; +public: + + static void ReadConfig(); + static void WriteConfig(); + + //helpers + static bool read_struct(const char *inifile, const char *section, const char * name,void * ptr,UINT size); + static void write_struct(const char *inifile, const char *section, const char * name,void * ptr,UINT size); + static void write_int(const char *inifile, const char *section, const char * name,int val); + static int read_int(const char *inifile, const char *section,const char * name,int def); + +protected: + CfgVar(const char * n) : name(n) {next=list;list=this;} + virtual void Read(const char * name)=0; + virtual void Write(const char * name)=0; +}; + +class CfgInt : private CfgVar +{ +private: + int def,value; +public: + CfgInt(const char * name,int _def) : CfgVar(name) {value=def=_def;} + inline int operator=(int x) {value=x;return value;} + inline operator int() {return value;} +private: + virtual void Read(const char * name); + virtual void Write(const char * name); +}; + +class CfgString : private CfgVar, public StringW +{ +private: + StringW def; +public: + CfgString(const char * name,const char * _def) : CfgVar(name), StringW(_def), def(_def) {} +private: + virtual void Read(const char * name); + virtual void Write(const char * name); +}; + +template<class T> +class CfgStructT : private CfgVar +{ +public: + T data; + CfgStructT(const char * name) : CfgVar(name) {} +private: + void Read(const char * name) { read_struct(INI_FILE, "in_vorbis",name,&data,sizeof(data));} + void Write(const char * name) {if (IsValueDefault()) WritePrivateProfileStringA("in_vorbis", name, 0, INI_FILE); else write_struct(INI_FILE, "in_vorbis", name, &data, sizeof(data));} +protected: + virtual bool IsValueDefault() {return 0;} +}; + + +class CfgFont : public CfgStructT<LOGFONT> +{ +private: + void get_def(LOGFONT * f) {memset(f,0,sizeof(LOGFONT));GetObject(GetStockObject(DEFAULT_GUI_FONT),sizeof(LOGFONT),f);} + virtual bool IsValueDefault() + { + LOGFONT t; + get_def(&t); + return !memcmp(&data,&t,sizeof(LOGFONT)); + } +public: + CfgFont(const char * name) : CfgStructT<LOGFONT>(name) + { + get_def(&data); + } +}; + +extern int32_t priority_tab[7]; +extern HINSTANCE hIns; + +extern CfgString cfg_ssave_format,cfg_dumpdir; + +int is_http(const char* url); + +class VorbisFile +{ +protected: + virtual int f_seek(__int64 offset,int whence)=0; + virtual size_t f_read(UINT siz,void * ptr)=0; + virtual UINT f_tell()=0; + static int _f_close(void *); + static int _f_seek(void* rs,__int64 offset,int whence); + static size_t _f_read(void* ptr,size_t size,size_t nmemb,void * rs); + static long _f_tell(void* rs); + static ov_callbacks oc; + static VorbisFile * Create_HTTP(const char * url,bool is_info); + VorbisFile(const wchar_t * u, bool is_info) : url(u) {memset(&vf,0,sizeof(vf));stopping=0;abort_prebuf=0;avg_kbps=0;use_prebuf=0;primary=!is_info; baseoffs=0;} + bool init(); + virtual void post_init() {}; + UINT avg_kbps; + bool Aborting(); + + __int64 baseoffs; +public: + enum {TYPE_LOCAL,TYPE_HTTP}; + virtual int GetType()=0; + virtual bool IsLive() {return 0;} + virtual void do_prebuf() {use_prebuf=1;abort_prebuf=0;}; + StringW url; + String withlp; + String stream_title; + bool stopping,abort_prebuf,use_prebuf; + bool primary;//display status messages or not + OggVorbis_File vf; + UINT get_avg_bitrate() + { + if (avg_kbps>0) return avg_kbps; + vorbis_info * vi=ov_info(&vf,-1); + if (!vi) return 0; + return vi->bitrate_nominal/1000; + } + + const char* get_meta(const char* tag,UINT c); + void set_meta(const vorbis_comment * vc,int links); + + static VorbisFile * Create(const wchar_t * url,bool is_info); + + double Length() {return ov_time_total(&vf,-1);} + double GetPos() {return ov_time_tell(&vf);} + int Seek(double p); + void Status(const wchar_t * zzz); + virtual UINT FileSize()=0; + + virtual ~VorbisFile() {ov_clear(&vf);} + virtual void Idle() {Sleep(10);} + + virtual void setBaseOffset(__int64 offs) { baseoffs=offs; } + + float GetGain(); +}; + +extern VorbisFile * theFile; + +extern StringW cur_file; + +extern CRITICAL_SECTION sync; + +BOOL modify_file(const wchar_t* url,const vorbis_comment * comments,int links); +void winampGetExtendedFileInfoW_Cleanup(void); +void UpdateFileTimeChanged(const wchar_t *fn); +void do_cfg(int s); +bool KeywordMatch(const char *mainString, const char *keyword); + +class Info +{ +public: + Info(const wchar_t *filename); + ~Info(); + bool Save(); + int Error() { return vc==0?1:0; } + int GetNumMetadataItems(); + void EnumMetadata(int n,wchar_t *key,int keylen, wchar_t *val, int vallen); + void RemoveMetadata(wchar_t * key); + void RemoveMetadata(int n); + void SetMetadata(wchar_t *key, wchar_t *val); + void SetMetadata(int n, wchar_t *key, wchar_t *val); + void SetTag(int n,wchar_t *key); // changes the key name +private: + const wchar_t *filename; + vorbis_comment * vc; + int numstreams, stream; +}; + +// {B6CB4A7C-A8D0-4c55-8E60-9F7A7A23DA0F} +static const GUID playbackConfigGroupGUID = + { 0xb6cb4a7c, 0xa8d0, 0x4c55, { 0x8e, 0x60, 0x9f, 0x7a, 0x7a, 0x23, 0xda, 0xf } }; + +#endif //IN_VORBIS_MAIN_H
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/mkv_vorbis_decoder.cpp b/Src/Plugins/Input/in_vorbis/mkv_vorbis_decoder.cpp new file mode 100644 index 00000000..39f1c1c3 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/mkv_vorbis_decoder.cpp @@ -0,0 +1,194 @@ +#include "mkv_vorbis_decoder.h" +#include "../nsmkv/Lacing.h" +#include "../nsmkv/Cluster.h" +#include <math.h> + + +int MKVDecoderCreator::CreateAudioDecoder(const char *codec_id, + const nsmkv::TrackEntryData *track_entry_data, const nsmkv::AudioData *audio_data, + unsigned int preferred_bits, unsigned int max_channels, bool floating_point, + ifc_mkvaudiodecoder **decoder) +{ + if (!strcmp(codec_id, "A_VORBIS")) + { + MKVVorbis *vorbis = new MKVVorbis; + vorbis_info_init(&vorbis->info); + vorbis_comment_init(&vorbis->comment); + nsmkv::LacingState lacing_state; + if (nsmkv::Lacing::GetState(nsmkv::BlockBinary::XIPH_LACING, (const uint8_t *)track_entry_data->codec_private, track_entry_data->codec_private_len, &lacing_state)) + { + const uint8_t *frame; + size_t frame_len; + uint16_t frame_number=0; + while (nsmkv::Lacing::GetFrame(frame_number, (const uint8_t *)track_entry_data->codec_private, track_entry_data->codec_private_len, &frame, &frame_len, &lacing_state)) + { + ogg_packet packet = {const_cast<uint8_t *>(frame), (long)frame_len, (frame_number==0), 0, 0 /*-1?*/, vorbis->packet_number++}; + int ret = vorbis_synthesis_headerin(&vorbis->info, &vorbis->comment, &packet); + if (ret != 0) + goto bail; + frame_number++; + } + if (vorbis_synthesis_init(&vorbis->dsp, &vorbis->info) == 0 + && vorbis_block_init(&vorbis->dsp, &vorbis->block) == 0) + { + vorbis->bps = preferred_bits?preferred_bits:16; + *decoder = vorbis; + return CREATEDECODER_SUCCESS; + } + } + +bail: + delete vorbis; + return CREATEDECODER_FAILURE; + } + + return CREATEDECODER_NOT_MINE; +} + + +#define CBCLASS MKVDecoderCreator +START_DISPATCH; +CB(CREATE_AUDIO_DECODER, CreateAudioDecoder) +END_DISPATCH; +#undef CBCLASS + +MKVVorbis::MKVVorbis() +{ + bps=16; + packet_number=0; +} + +#define PA_CLIP_( val, min, max )\ + { val = ((val) < (min)) ? (min) : (((val) > (max)) ? (max) : (val)); } + +#if defined(_M_IX86) +static __inline long float_to_long(double t) +{ + long r; + __asm fld t + __asm fistp r + return r; +} +#else +#define float_to_long(x) ((long)( x )) +#endif + +inline static void clip(double &x, double a, double b) +{ + double x1 = fabs (x - a); + double x2 = fabs (x - b); + x = x1 + (a + b); + x -= x2; + x *= 0.5; +} + +static void Float32_To_Int24_Clip(void *destinationBuffer, void *sourceBuffer, size_t count, size_t channels, double gain) +{ + float *src = (float*)sourceBuffer; + unsigned char *dest = (unsigned char*)destinationBuffer; + gain*=65536.*32768.; + while ( count-- ) + { + /* convert to 32 bit and drop the low 8 bits */ + double scaled = *src * gain; + clip( scaled, -2147483648., 2147483647.); + signed long temp = (signed long) scaled; + + dest[0] = (unsigned char)(temp >> 8); + dest[1] = (unsigned char)(temp >> 16); + dest[2] = (unsigned char)(temp >> 24); + + src++; + dest += 3*channels; + } +} + +static void Float32_To_Int16_Clip(void *destinationBuffer, void *sourceBuffer, size_t count, size_t channels, double gain) +{ + float *src = (float*)sourceBuffer; + signed short *dest = (signed short*)destinationBuffer; + + gain*=32768.0; + while ( count-- ) + { + long samp = float_to_long((*src) * gain/* - 0.5*/); + + PA_CLIP_( samp, -0x8000, 0x7FFF ); + *dest = (signed short) samp; + + src ++; + dest += channels; + } +} + +int MKVVorbis::DecodeBlock(void *inputBuffer, size_t inputBufferBytes, void *outputBuffer, size_t *outputBufferBytes) +{ + uint8_t *out = (uint8_t *)outputBuffer; + ogg_packet packet = {(uint8_t *)inputBuffer, (long)inputBufferBytes, 0, 0, 0 -1, packet_number++}; + int ret = vorbis_synthesis(&block, &packet); + if (ret == 0) + { + vorbis_synthesis_blockin(&dsp,&block); + long channels = info.channels; + float **pcm; + int samples = vorbis_synthesis_pcmout(&dsp, &pcm); + if (samples) + { + switch(bps) + { + case 16: + for(int i=0;i<channels;i++) + { + Float32_To_Int16_Clip(out, pcm[i], samples, channels, 1.0 /*gain*/); + out+=2; + } + break; + case 24: + for(int i=0;i<channels;i++) + { + Float32_To_Int24_Clip(out, pcm[i], samples, channels, 1.0 /*gain*/); + out+=3; + } + break; + } + } + *outputBufferBytes = samples*channels*bps/8; + // let the decoder know we're processed them + vorbis_synthesis_read(&dsp,samples); + return MKV_SUCCESS; + } + return MKV_FAILURE; +} + +int MKVVorbis::GetOutputProperties(unsigned int *sampleRate, unsigned int *channels, unsigned int *bitsPerSample, bool *isFloat) +{ + *sampleRate = info.rate; + *channels = info.channels; + *bitsPerSample = bps; + *isFloat = false; // TODO + return MKV_SUCCESS; +} + +void MKVVorbis::Flush() +{ + vorbis_synthesis_restart(&dsp); +} + +void MKVVorbis::Close() +{ + // TODO: benski> verify + vorbis_info_clear(&info); + vorbis_comment_clear(&comment); + vorbis_dsp_clear(&dsp); + vorbis_block_clear(&block); + delete this; +} +#define CBCLASS MKVVorbis +START_DISPATCH; +//CB(OUTPUT_FRAME_SIZE, OutputFrameSize) +CB(GET_OUTPUT_PROPERTIES, GetOutputProperties) +CB(DECODE_BLOCK, DecodeBlock) +VCB(FLUSH, Flush) +VCB(CLOSE, Close) +END_DISPATCH; +#undef CBCLASS
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/mkv_vorbis_decoder.h b/Src/Plugins/Input/in_vorbis/mkv_vorbis_decoder.h new file mode 100644 index 00000000..0893ab25 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/mkv_vorbis_decoder.h @@ -0,0 +1,41 @@ +#pragma once +#include "../in_mkv/ifc_mkvaudiodecoder.h" +#include "../in_mkv/svc_mkvdecoder.h" +#include <vorbis/codec.h> + +// {6058D315-2F08-4b2f-903E-4C2E6B5EFFA9} +static const GUID mkv_vorbis_guid = +{ 0x6058d315, 0x2f08, 0x4b2f, { 0x90, 0x3e, 0x4c, 0x2e, 0x6b, 0x5e, 0xff, 0xa9 } }; + + +class MKVDecoderCreator : public svc_mkvdecoder +{ +public: + static const char *getServiceName() { return "Vorbis MKV Decoder"; } + static GUID getServiceGuid() { return mkv_vorbis_guid; } + int CreateAudioDecoder(const char *codec_id, + const nsmkv::TrackEntryData *track_entry_data, const nsmkv::AudioData *audio_data, + unsigned int preferred_bits, unsigned int max_channels, bool floating_point, + ifc_mkvaudiodecoder **decoder); +protected: + RECVS_DISPATCH; +}; + +class MKVVorbis : public ifc_mkvaudiodecoder +{ +public: + MKVVorbis(); + int DecodeBlock(void *inputBuffer, size_t inputBufferBytes, void *outputBuffer, size_t *outputBufferBytes); + int GetOutputProperties(unsigned int *sampleRate, unsigned int *channels, unsigned int *bitsPerSample, bool *isFloat); + void Flush(); + void Close(); +//private: + unsigned int bps; + vorbis_info info; + vorbis_dsp_state dsp; + vorbis_block block; + vorbis_comment comment; + ogg_int64_t packet_number; +protected: + RECVS_DISPATCH; +};
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/112.png b/Src/Plugins/Input/in_vorbis/oggdrop/112.png Binary files differnew file mode 100644 index 00000000..4799bd0f --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/112.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/113.png b/Src/Plugins/Input/in_vorbis/oggdrop/113.png Binary files differnew file mode 100644 index 00000000..4cd9b4ac --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/113.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/114.png b/Src/Plugins/Input/in_vorbis/oggdrop/114.png Binary files differnew file mode 100644 index 00000000..88192596 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/114.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/115.png b/Src/Plugins/Input/in_vorbis/oggdrop/115.png Binary files differnew file mode 100644 index 00000000..60c94b0b --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/115.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/116.png b/Src/Plugins/Input/in_vorbis/oggdrop/116.png Binary files differnew file mode 100644 index 00000000..1d6fb8a2 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/116.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/117.png b/Src/Plugins/Input/in_vorbis/oggdrop/117.png Binary files differnew file mode 100644 index 00000000..135963e7 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/117.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/118.png b/Src/Plugins/Input/in_vorbis/oggdrop/118.png Binary files differnew file mode 100644 index 00000000..57a3a1ac --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/118.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/119.png b/Src/Plugins/Input/in_vorbis/oggdrop/119.png Binary files differnew file mode 100644 index 00000000..a3baf233 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/119.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/120.png b/Src/Plugins/Input/in_vorbis/oggdrop/120.png Binary files differnew file mode 100644 index 00000000..fb6a3ce9 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/120.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/121.png b/Src/Plugins/Input/in_vorbis/oggdrop/121.png Binary files differnew file mode 100644 index 00000000..23ff9813 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/121.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/122.png b/Src/Plugins/Input/in_vorbis/oggdrop/122.png Binary files differnew file mode 100644 index 00000000..6b52d9e2 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/122.png diff --git a/Src/Plugins/Input/in_vorbis/oggdrop/123.png b/Src/Plugins/Input/in_vorbis/oggdrop/123.png Binary files differnew file mode 100644 index 00000000..60284d13 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/oggdrop/123.png diff --git a/Src/Plugins/Input/in_vorbis/resource.h b/Src/Plugins/Input/in_vorbis/resource.h new file mode 100644 index 00000000..425c40ea --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/resource.h @@ -0,0 +1,177 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by ogg.rc +// +#define IDS_NULLSOFT_VORBIS_DECODER_OLD 0 +#define IDS_PLEASE_ENTER_TAG_NAME 1 +#define IDS_TAG_NAME_CONTAINS_INVALID_CHARS 2 +#define IDOKAUTH 3 +#define IDS_ERASE_ALL_FIELDS_ON_LIST 3 +#define IDCANCELAUTH 4 +#define IDS_WARNING 4 +#define IDS_FILE_ERROR 5 +#define IDS_LENGTH 6 +#define IDS_AVERAGE_BITRATE 7 +#define IDS_FILE_SIZE 8 +#define IDS_NOMINAL_BITRATE 9 +#define IDS_MIN_BITRATE 10 +#define IDS_MAX_BITRATE 11 +#define IDS_CHANNELS 12 +#define IDS_SAMPLING_RATE 13 +#define IDS_SERIAL_NUMBER 14 +#define IDS_VERSION 15 +#define IDS_Vendor 16 +#define IDS_VENDOR 16 +#define IDS_TO_SIMPLE_MODE 17 +#define IDS_TO_ADVANCED_MODE 18 +#define IDS_OGG_VORBIS_INFO 19 +#define IDS_WRITE_ERROR 20 +#define IDS_BEST_RPM 21 +#define IDS_ABOUT 22 +#define IDS_LEAVE_AS_IS 24 +#define IDS_REMAP_6_CHANNELS 25 +#define IDS_DOWNMIX_TO_4_CHANNELS 26 +#define IDS_DOWNMIX_TO_2_CHANNELS_DS 27 +#define IDS_DOWNMIX_TO_2_CHANNELS_DS2 28 +#define IDS_DOWNMIX_TO_MONO 29 +#define IDS_CORRECT_FL_FC_FR_BL_BR_LFE 30 +#define IDS_BROKEN_FL_FR_FC_BL_BR_LFE 31 +#define IDS_IDLE 32 +#define IDS_ABOUT_TEXT 32 +#define IDS_LOWEST 33 +#define IDS_BELOW_NORMAL 34 +#define IDS_NORMAL 35 +#define IDS_ABOVE_NORMAL 36 +#define IDS_HIGHEST 37 +#define IDS_TIME_CRITICAL 38 +#define IDS_TITLE_PREFERENCES 39 +#define IDS_DO_NOT_ENABLE_24_BIT_OUTPUT 40 +#define IDS_ONE_TIME_FAQ_REMINDER 41 +#define IDS_RUNNING_ON_NT_OS 42 +#define IDS_RUNNING_ON_WIN9X 43 +#define IDS_NEVER 44 +#define IDS_PORT_80_ONLY 45 +#define IDS_ALWAYS 46 +#define IDS_SELECT_OUTPUT_DIRECTORY 47 +#define IDS_DECODING 48 +#define IDS_DISPLAY 49 +#define IDS_STREAMING 50 +#define IDS_CONNECTING 51 +#define IDS_PREBUFFERING 52 +#define IDS_AUTH_REQUIRED 53 +#define IDS_OGG_FILES 54 +#define IDS_NAME 55 +#define IDS_VALUE 56 +#define IDS_KBPS 57 +#define IDS_STRING2 58 +#define IDS_HZ 58 +#define IDS_GAME_SPEED 59 +#define IDS_STRING1 60 +#define IDS_BYTES 60 +#define IDS_FAMILY_STRING 61 +#define IDC_CONFIG_TAB1 101 +#define IDD_INFO_DLG 102 +#define IDC_CONFIG_TAB2 102 +#define IDC_CONFIG_TAB3 103 +#define IDD_INFO_DLG1 104 +#define IDC_CONFIG_TAB4 104 +#define IDD_ABOUT 112 +#define IDB_BITMAP1 115 +#define IDB_BITMAP2 116 +#define IDB_BITMAP3 117 +#define IDB_BITMAP4 118 +#define IDB_BITMAP5 119 +#define IDB_BITMAP6 120 +#define IDB_BITMAP7 121 +#define IDB_BITMAP8 122 +#define IDB_BITMAP9 123 +#define IDB_BITMAP10 124 +#define IDB_BITMAP11 125 +#define IDB_BITMAP12 126 +#define IDD_HTTPAUTH 128 +#define IDD_INFO 131 +#define IDD_DIALOG1 132 +#define IDD_CONFIG 132 +#define IDD_INFO_DLG_NEW 133 +#define IDD_INFO_PANEL_ADVANCED 134 +#define IDD_INFO_PANEL_SIMPLE 135 +#define IDB_PNG1 136 +#define IDB_PNG2 137 +#define IDB_PNG3 138 +#define IDB_PNG4 139 +#define IDB_PNG5 140 +#define IDB_PNG6 141 +#define IDB_PNG7 142 +#define IDB_PNG8 143 +#define IDB_PNG9 144 +#define IDB_PNG10 145 +#define IDB_PNG11 146 +#define IDB_PNG12 147 +#define IDC_LIST 1001 +#define IDC_NAME 1002 +#define IDC_TITLE 1002 +#define IDC_VALUE 1003 +#define IDC_ARTIST 1003 +#define IDC_HTTP_BSIZE 1004 +#define IDC_ALBUM 1004 +#define IDC_STREAM_SAVE 1005 +#define IDC_GENRE 1005 +#define IDC_FSAVE 1006 +#define IDC_YEAR 1006 +#define IDC_DATE 1006 +#define IDC_CUSTOM1 1007 +#define IDC_MISC 1007 +#define IDC_AVG_BR 1008 +#define IDC_FIX0R 1009 +#define IDC_PROXY 1012 +#define IDC_URL 1012 +#define IDC_SLIDER1 1013 +#define IDC_SLIDER2 1014 +#define IDC_BUTTON_ADD 1015 +#define IDC_BUTTON_DEL 1016 +#define IDC_BUTTON_DELALL 1017 +#define IDC_RPM 1018 +#define IDC_RPM2 1019 +#define IDC_MC6_DM 1020 +#define IDC_MC6_MAP 1021 +#define IDC_SSAVE_FMT 1022 +#define IDC_SSAVE_FMT_DEF 1023 +#define IDC_FULLBUF 1025 +#define IDC_EDITAUTH 1026 +#define IDC_REALM 1027 +#define IDC_TRACK 1028 +#define IDC_STATIC_MISC 1034 +#define IDC_STATIC_TAGS 1035 +#define IDC_STATIC_STD 1036 +#define IDC_STATIC_TRACK 1037 +#define IDC_SEPARATE 1038 +#define IDC_DELETE_ALL 1039 +#define IDC_RG 1040 +#define IDC_RG_MODE 1041 +#define IDC_NOCLIP 1042 +#define IDC_HARDLIMIT 1043 +#define IDC_PREAMP_STAT 1044 +#define IDC_TAB 1045 +#define IDC_MODE_TOGGLE 1053 +#define IDC_NEXT_STREAM 1054 +#define IDC_PREV_STREAM 1055 +#define IDC_STATIC_CS 1056 +#define IDC_HIDE_SPEC 1058 +#define IDC_COMMENT 1060 +#define IDC_ABOUT_TEXT 1061 +#define IDC_OS_BLAH 1062 +#define IDC_REMEMBER_INFOSIZE 1063 +#define IDC_FONTNAME 1064 +#define IDC_PREAMP_RG 1065 +#define IDS_NULLSOFT_VORBIS_DECODER 65534 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 148 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1067 +#define _APS_NEXT_SYMED_VALUE 105 +#endif +#endif diff --git a/Src/Plugins/Input/in_vorbis/rf.h b/Src/Plugins/Input/in_vorbis/rf.h new file mode 100644 index 00000000..70bd85bb --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/rf.h @@ -0,0 +1,108 @@ +#ifndef _RF_H_ +#define _RF_H_ + +//based on Tempura specs. +//NOT compatible with WA3 alphas + +class WReader +{ + protected: + + /* WReader + ** WReader constructor + */ + WReader() : m_player(0) { } + + public: + + /* m_player + ** Filled by Winamp. Pointer to Winamp 3 core interface + */ + /*WPlayer_callback*/ void *m_player; //PP: hack. read_file.dll doesn't call it at all. simply don't touch it + + /* GetDescription + ** Retrieves your plug-in's text description + */ + virtual char *GetDescription() { return "Unknown"; }; + + /* Open + ** Used to open a file, return 0 on success + */ + virtual int Open(char *url, bool *killswitch)=0; + + /* Read + ** Returns number of BYTES read (if < length then eof or killswitch) + */ + virtual int Read(char *buffer, int length, bool *killswitch)=0; + + /* GetLength + ** Returns length of the entire file in BYTES, return -1 on unknown/infinite (as for a stream) + */ + virtual int GetLength(void)=0; + + /* CanSeek + ** Returns 1 if you can skip ahead in the file, 0 if not + */ + virtual int CanSeek(void)=0; //PP: currently available read_file.dll vesions can always seek in any direction + + /* Seek + ** Jump to a certain absolute position + */ + virtual int Seek(int position, bool *killswitch)=0; + + /* GetHeader + ** Retrieve header. Used in read_http to retrieve the HTTP header + */ + virtual char *GetHeader(char *name) { return 0; } + + /* ~WReader + ** WReader virtual destructor + */ + //virtual ~WReader() { } + virtual void Release(int) {}; + //PP: hack - shut up linker when getting rid of evil CRT library; seems to work OK under Tempura +}; + + + + +#define READ_VER 0x100 + +typedef struct +{ + /* version + ** Version revision number + */ + int version; + + /* description + ** Text description of the reader plug-in + */ + char *description; + + /* create + ** Function pointer to create a reader module + */ + WReader *(*create)(); + + /* ismine + ** Determines whether or not a file should be read by this plug-in + */ + int (*ismine)(char *url); + +} reader_source; + +//exported symbol is: +//int readerSource(HINSTANCE,reader_source**); + +/* +(not a part of Tempura specs) +int _stdcall gzip_writefile(char* path,void* buf,DWORD size) - writes a memory block to a GZIP file - in_midi calls it from file info box + +other hacks: +recent versions understand file://... urls, can do partial file access (eg. "partial://00006666-66660000:c:\foo\bar.dat\zzz.wav" (zzz.wav is the "display name" + extension to make winamp select correct plug-in) and auto-detect CD drive letter (eg. #:\x.mp3 will scan all drives for that file; also works with partial:// ) +you can (for an example) build a playlist which will play Unreal soundtrack directly from the game CD on any system +latest read_file.dll is bundled with the midi plug-in: http://www.blorp.com/~peter/zips/in_midi.zip +*/ + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/shaper.cpp b/Src/Plugins/Input/in_vorbis/shaper.cpp new file mode 100644 index 00000000..85779a87 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/shaper.cpp @@ -0,0 +1,245 @@ +#include "Shaper.h" + +#ifndef M_PI +#define M_PI 3.1415926535897932384626433832795028842 +#endif + +#define RANDBUFLEN 65536 + +#define RINT(x) ((x) >= 0 ? ((int)((x) + 0.5)) : ((int)((x) - 0.5))) + +const int scoeffreq[] = + { + 0, 48000, 44100, 37800, 32000, 22050, 48000, 44100 + }; + + +const int scoeflen[] = + { + 1, 16, 20, 16, 16, 15, 16, 15 + }; + +const int samp[] = + { + 8, 18, 27, 8, 8, 8, 10, 9 + }; + +const double shapercoefs[8][21] = + { + { + -1 + } + , /* triangular dither */ + + { -2.8720729351043701172, 5.0413231849670410156, -6.2442994117736816406, 5.8483986854553222656, + -3.7067542076110839844, 1.0495119094848632812, 1.1830236911773681641, -2.1126792430877685547, + 1.9094531536102294922, -0.99913084506988525391, 0.17090806365013122559, 0.32615602016448974609, + -0.39127644896507263184, 0.26876461505889892578, -0.097676105797290802002, 0.023473845794796943665, + }, /* 48k, N=16, amp=18 */ + + { -2.6773197650909423828, 4.8308925628662109375, -6.570110321044921875, 7.4572014808654785156, + -6.7263274192810058594, 4.8481650352478027344, -2.0412089824676513672, -0.7006359100341796875, + 2.9537565708160400391, -4.0800385475158691406, 4.1845216751098632812, -3.3311812877655029297, + 2.1179926395416259766, -0.879302978515625, 0.031759146600961685181, 0.42382788658142089844, + -0.47882103919982910156, 0.35490813851356506348, -0.17496839165687561035, 0.060908168554306030273, + }, /* 44.1k, N=20, amp=27 */ + + { -1.6335992813110351562, 2.2615492343902587891, -2.4077029228210449219, 2.6341717243194580078, + -2.1440362930297851562, 1.8153258562088012695, -1.0816224813461303711, 0.70302653312683105469, + -0.15991993248462677002, -0.041549518704414367676, 0.29416576027870178223, -0.2518316805362701416, + 0.27766478061676025391, -0.15785403549671173096, 0.10165894031524658203, -0.016833892092108726501, + }, /* 37.8k, N=16 */ + + { -0.82901298999786376953, 0.98922657966613769531, -0.59825712442398071289, 1.0028809309005737305, + -0.59938216209411621094, 0.79502451419830322266, -0.42723315954208374023, 0.54492527246475219727, + -0.30792605876922607422, 0.36871799826622009277, -0.18792048096656799316, 0.2261127084493637085, + -0.10573341697454452515, 0.11435490846633911133, -0.038800679147243499756, 0.040842197835445404053, + }, /* 32k, N=16 */ + + { -0.065229974687099456787, 0.54981261491775512695, 0.40278548002243041992, 0.31783768534660339355, + 0.28201797604560852051, 0.16985194385051727295, 0.15433363616466522217, 0.12507140636444091797, + 0.08903945237398147583, 0.064410120248794555664, 0.047146003693342208862, 0.032805237919092178345, + 0.028495194390416145325, 0.011695005930960178375, 0.011831838637590408325, + }, /* 22.05k, N=15 */ + + { -2.3925774097442626953, 3.4350297451019287109, -3.1853709220886230469, 1.8117271661758422852, + 0.20124770700931549072, -1.4759907722473144531, 1.7210904359817504883, -0.97746700048446655273, + 0.13790138065814971924, 0.38185903429985046387, -0.27421241998672485352, -0.066584214568138122559, + 0.35223302245140075684, -0.37672343850135803223, 0.23964276909828186035, -0.068674825131893157959, + }, /* 48k, N=16, amp=10 */ + + { -2.0833916664123535156, 3.0418450832366943359, -3.2047898769378662109, 2.7571926116943359375, + -1.4978630542755126953, 0.3427594602108001709, 0.71733748912811279297, -1.0737057924270629883, + 1.0225815773010253906, -0.56649994850158691406, 0.20968692004680633545, 0.065378531813621520996, + -0.10322438180446624756, 0.067442022264003753662, 0.00495197344571352005, + }, /* 44.1k, N=15, amp=9 */ + +#if 0 + { -3.0259189605712890625, 6.0268716812133789062, -9.195003509521484375, 11.824929237365722656, + -12.767142295837402344, 11.917946815490722656, -9.1739168167114257812, 5.3712320327758789062, + -1.1393624544143676758, -2.4484779834747314453, 4.9719839096069335938, -6.0392003059387207031, + 5.9359521865844726562, -4.903278350830078125, 3.5527443885803222656, -2.1909697055816650391, + 1.1672389507293701172, -0.4903914332389831543, 0.16519790887832641602, -0.023217858746647834778, + }, /* 44.1k, N=20 */ +#endif + }; + +#define POOLSIZE 97 + +Shaper::Shaper(int freq, int _nch, int min, int max, int _dtype, int pdf, double noiseamp) +{ + int i; + float pool[POOLSIZE] = {0}; + + nch = _nch; + dtype = _dtype; + + for (i = 1;i < 6;i++) if (freq == scoeffreq[i]) break; + /* if ((dtype == 3 || dtype == 4) && i == 6) { + fprintf(stderr,"Warning: ATH based noise shaping for destination frequency %dHz is not available, using triangular dither\n",freq); + }*/ + if (dtype == 2 || i == 6) i = 0; + if (dtype == 4 && (i == 1 || i == 2)) i += 5; + + shaper_type = i; + + shapebuf = (double**)malloc(sizeof(double *) * nch); + shaper_len = scoeflen[shaper_type]; + + for (i = 0;i < nch;i++) + shapebuf[i] = (double*)calloc(shaper_len, sizeof(double)); + + shaper_clipmin = min; + shaper_clipmax = max; + + randbuf = (REAL*)malloc(sizeof(REAL) * RANDBUFLEN); + + for (i = 0;i < POOLSIZE;i++) pool[i] = warandf(); + + switch (pdf) + { + case DITHER_RECTANGLE: // rectangular + for (i = 0;i < RANDBUFLEN;i++) + { + float r; + int p; + + p = warand() % POOLSIZE; + r = pool[p]; pool[p] = warandf(); + randbuf[i] = (REAL)(noiseamp * (((double)r) - 0.5)); + } + break; + + case DITHER_TRIANGLE: + for (i = 0;i < RANDBUFLEN;i++) + { + float r1, r2; + int p; + + p = warand() % POOLSIZE; + r1 = pool[p]; pool[p] = warandf(); + p = warand() % POOLSIZE; + r2 = pool[p]; pool[p] = warandf(); + randbuf[i] = (REAL)(noiseamp * ((((double)r1)) - (((double)r2)))); + } + break; +#if 0 + case DITHER_GAUSSIAN: // gaussian + for (i = 0;i < RANDBUFLEN;i++) + { + int sw = 0; + double t, u; + double r; + int p; + + if (sw == 0) + { + sw = 1; + + p = warand() % POOLSIZE; + r = ((double)pool[p]); pool[p] = warandf(); + + t = sqrt(-2 * log(1 - r)); + + p = warand() % POOLSIZE; + r = ((double)pool[p]); pool[p] = warandf(); + + u = 2 * M_PI * r; + + randbuf[i] = noiseamp * t * cos(u); + } + else + { + sw = 0; + + randbuf[i] = noiseamp * t * sin(u); + } + } + break; +#endif + } + + randptr = 0; + +// if (dtype == 0 || dtype == 1) return 1; + //return samp[shaper_type]; +} + +Shaper::~Shaper() +{ + int i; + + for (i = 0;i < nch;i++) free(shapebuf[i]); + free(shapebuf); + free(randbuf); +} + +int Shaper::do_shaping(double s,/*double *peak,*/int ch) +{ + double u, h; + int i; + + if (dtype == 1) + { + s += randbuf[randptr++ & (RANDBUFLEN-1)]; + + if (s < shaper_clipmin) + { + //double d = (double)s / shaper_clipmin; + //*peak = *peak < d ? d : *peak; + s = shaper_clipmin; + } + if (s > shaper_clipmax) + { + //double d = (double)s / shaper_clipmax; + //*peak = *peak < d ? d : *peak; + s = shaper_clipmax; + } + + return RINT(s); + } + + h = 0; + for (i = 0;i < shaper_len;i++) + h += shapercoefs[shaper_type][i] * shapebuf[ch][i]; + s += h; + u = s; + s += randbuf[randptr++ & (RANDBUFLEN-1)]; + if (s < shaper_clipmin) + { + //double d = (double)s / shaper_clipmin; + //*peak = *peak < d ? d : *peak; + s = shaper_clipmin; + } + if (s > shaper_clipmax) + { + //double d = (double)s / shaper_clipmax; + //*peak = *peak < d ? d : *peak; + s = shaper_clipmax; + } + s = RINT(s); + for (i = shaper_len - 2;i >= 0;i--) shapebuf[ch][i+1] = shapebuf[ch][i]; + shapebuf[ch][0] = s - u; + + return (int)s; +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/shaper.h b/Src/Plugins/Input/in_vorbis/shaper.h new file mode 100644 index 00000000..13da7fd2 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/shaper.h @@ -0,0 +1,30 @@ +//from SSRC +#ifndef NULLSOFT_VORBIS_SHAPER_H +#define NULLSOFT_VORBIS_SHAPER_H +#include "main.h" + +typedef float REAL; +enum +{ + DITHER_RECTANGLE=0, + DITHER_TRIANGLE=1, + DITHER_GAUSSIAN=2, +}; +class Shaper +{ + double **shapebuf; + int shaper_type,shaper_len,shaper_clipmin,shaper_clipmax; + REAL *randbuf; + int randptr; + int dtype; + int nch; + + public: + Shaper(int freq,int _nch,int min,int max,int _dtype,int pdf,double noiseamp); + + int do_shaping(double s,/*double *peak,*/int ch); + + ~Shaper(); +}; + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/unihack.cpp b/Src/Plugins/Input/in_vorbis/unihack.cpp new file mode 100644 index 00000000..ada2e3d8 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/unihack.cpp @@ -0,0 +1,2 @@ +#include "main.h" + diff --git a/Src/Plugins/Input/in_vorbis/vcedit.c b/Src/Plugins/Input/in_vorbis/vcedit.c new file mode 100644 index 00000000..25f40cd8 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/vcedit.c @@ -0,0 +1,491 @@ +/* This program is licensed under the GNU Library General Public License, version 2, + * a copy of which is included with this program (LICENCE.LGPL). + * + * (c) 2000-2001 Michael Smith <msmith@labyrinth.net.au> + * + * + * Comment editing backend, suitable for use by nice frontend interfaces. + * + * last modified: $Id: vcedit.c,v 1.3 2013/10/22 14:17:11 dromagod Exp $ + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <ogg/ogg.h> +#include <vorbis/codec.h> + +#include "vcedit.h" +//#include "i18n.h" + + +#define CHUNKSIZE 4096 + +vcedit_state *vcedit_new_state(void) +{ + vcedit_state *state = malloc(sizeof(vcedit_state)); + memset(state, 0, sizeof(vcedit_state)); + + return state; +} + +char *vcedit_error(vcedit_state *state) +{ + return state->lasterror; +} + +vorbis_comment *vcedit_comments(vcedit_state *state) +{ + return state->vc; +} + +static void vcedit_clear_internals(vcedit_state *state) +{ + if(state->vc) + { + vorbis_comment_clear(state->vc); + free(state->vc); + } + if(state->os) + { + ogg_stream_clear(state->os); + free(state->os); + } + if(state->oy) + { + ogg_sync_clear(state->oy); + free(state->oy); + } + if(state->vendor) + free(state->vendor); + if(state->mainbuf) + free(state->mainbuf); + if(state->bookbuf) + free(state->bookbuf); + if(state->vi) { + vorbis_info_clear(state->vi); + free(state->vi); + } + + memset(state, 0, sizeof(*state)); +} + +void vcedit_clear(vcedit_state *state) +{ + if(state) + { + vcedit_clear_internals(state); + free(state); + } +} + +/* Next two functions pulled straight from libvorbis, apart from one change + * - we don't want to overwrite the vendor string. + */ +static void _v_writestring(oggpack_buffer *o,char *s, int len) +{ + while(len--) + { + oggpack_write(o,*s++,8); + } +} + +static int _commentheader_out(vorbis_comment *vc, char *vendor, ogg_packet *op) +{ + oggpack_buffer opb; + + oggpack_writeinit(&opb); + + /* preamble */ + oggpack_write(&opb,0x03,8); + _v_writestring(&opb,"vorbis", 6); + + /* vendor */ + oggpack_write(&opb,(unsigned long)strlen(vendor),32); + _v_writestring(&opb,vendor, (int)strlen(vendor)); + + /* comments */ + oggpack_write(&opb,vc->comments,32); + if(vc->comments){ + int i; + for(i=0;i<vc->comments;i++){ + if(vc->user_comments[i]){ + oggpack_write(&opb,vc->comment_lengths[i],32); + _v_writestring(&opb,vc->user_comments[i], + vc->comment_lengths[i]); + }else{ + oggpack_write(&opb,0,32); + } + } + } + oggpack_write(&opb,1,1); + + op->packet = _ogg_malloc(oggpack_bytes(&opb)); + memcpy(op->packet, opb.buffer, oggpack_bytes(&opb)); + + op->bytes=oggpack_bytes(&opb); + op->b_o_s=0; + op->e_o_s=0; + op->granulepos=0; + + oggpack_writeclear(&opb); + return 0; +} + +static int _blocksize(vcedit_state *s, ogg_packet *p) +{ + int this = vorbis_packet_blocksize(s->vi, p); + int ret = (this + s->prevW)/4; + + if(!s->prevW) + { + s->prevW = this; + return 0; + } + + s->prevW = this; + return ret; +} + +static int _fetch_next_packet(vcedit_state *s, ogg_packet *p, ogg_page *page) +{ + int result = ogg_stream_packetout(s->os, p); + + if(result > 0) + return 1; + else + { + if(s->eosin) + return 0; + while(ogg_sync_pageout(s->oy, page) <= 0) + { + char *buffer = ogg_sync_buffer(s->oy, CHUNKSIZE); + int bytes = (int)s->read(buffer,1, CHUNKSIZE, s->in); + ogg_sync_wrote(s->oy, bytes); + if(bytes == 0) + return 0; + } + if(ogg_page_eos(page)) + s->eosin = 1; + else if(ogg_page_serialno(page) != s->serial) + { + s->eosin = 1; + s->extrapage = 1; + return 0; + } + + ogg_stream_pagein(s->os, page); + return _fetch_next_packet(s, p, page); + } +} + +int vcedit_open(vcedit_state *state, FILE *in) +{ + return vcedit_open_callbacks(state, (void *)in, + (vcedit_read_func)fread, (vcedit_write_func)fwrite); +} + +int vcedit_open_callbacks(vcedit_state *state, void *in, + vcedit_read_func read_func, vcedit_write_func write_func) +{ + + char *buffer; + int bytes,i; + ogg_packet *header; + ogg_packet header_main; + ogg_packet header_comments; + ogg_packet header_codebooks; + ogg_page og; + + state->in = in; + state->read = read_func; + state->write = write_func; + + state->oy = malloc(sizeof(ogg_sync_state)); + ogg_sync_init(state->oy); + + buffer = ogg_sync_buffer(state->oy, CHUNKSIZE); + bytes = (int)state->read(buffer, 1, CHUNKSIZE, state->in); + + ogg_sync_wrote(state->oy, bytes); + + if(ogg_sync_pageout(state->oy, &og) != 1) + { + if(bytes<CHUNKSIZE) + state->lasterror = "Input truncated or empty."; + else + state->lasterror = "Input is not an Ogg bitstream."; + goto err; + } + + state->serial = ogg_page_serialno(&og); + + state->os = malloc(sizeof(ogg_stream_state)); + ogg_stream_init(state->os, state->serial); + + state->vi = malloc(sizeof(vorbis_info)); + vorbis_info_init(state->vi); + + state->vc = malloc(sizeof(vorbis_comment)); + vorbis_comment_init(state->vc); + + if(ogg_stream_pagein(state->os, &og) < 0) + { + state->lasterror = "Error reading first page of Ogg bitstream."; + goto err; + } + + if(ogg_stream_packetout(state->os, &header_main) != 1) + { + state->lasterror = "Error reading initial header packet."; + goto err; + } + + if(vorbis_synthesis_headerin(state->vi, state->vc, &header_main) < 0) + { + state->lasterror = "Ogg bitstream does not contain vorbis data."; + goto err; + } + + state->mainlen = header_main.bytes; + state->mainbuf = malloc(state->mainlen); + memcpy(state->mainbuf, header_main.packet, header_main.bytes); + + i = 0; + header = &header_comments; + while(i<2) { + while(i<2) { + int result = ogg_sync_pageout(state->oy, &og); + if(result == 0) break; /* Too little data so far */ + else if(result == 1) + { + ogg_stream_pagein(state->os, &og); + while(i<2) + { + result = ogg_stream_packetout(state->os, header); + if(result == 0) break; + if(result == -1) + { + state->lasterror = "Corrupt secondary header."; + goto err; + } + vorbis_synthesis_headerin(state->vi, state->vc, header); + if(i==1) + { + state->booklen = header->bytes; + state->bookbuf = malloc(state->booklen); + memcpy(state->bookbuf, header->packet, + header->bytes); + } + i++; + header = &header_codebooks; + } + } + } + + buffer = ogg_sync_buffer(state->oy, CHUNKSIZE); + bytes = (int)state->read(buffer, 1, CHUNKSIZE, state->in); + if(bytes == 0 && i < 2) + { + state->lasterror = "EOF before end of vorbis headers."; + goto err; + } + ogg_sync_wrote(state->oy, bytes); + } + + /* Copy the vendor tag */ + bytes = (int)strlen(state->vc->vendor); + state->vendor = malloc(bytes +1); + strncpy(state->vendor, state->vc->vendor, bytes); + + /* Headers are done! */ + return 0; + +err: + vcedit_clear_internals(state); + return -1; +} + +int vcedit_write(vcedit_state *state, void *out) +{ + ogg_stream_state streamout; + ogg_packet header_main; + ogg_packet header_comments; + ogg_packet header_codebooks; + + ogg_page ogout, ogin; + ogg_packet op; + ogg_int64_t granpos = 0; + int result; + char *buffer; + int bytes; + int needflush=0, needout=0; + + state->eosin = 0; + state->extrapage = 0; + + header_main.bytes = state->mainlen; + header_main.packet = state->mainbuf; + header_main.b_o_s = 1; + header_main.e_o_s = 0; + header_main.granulepos = 0; + + header_codebooks.bytes = state->booklen; + header_codebooks.packet = state->bookbuf; + header_codebooks.b_o_s = 0; + header_codebooks.e_o_s = 0; + header_codebooks.granulepos = 0; + + ogg_stream_init(&streamout, state->serial); + + _commentheader_out(state->vc, state->vendor, &header_comments); + + ogg_stream_packetin(&streamout, &header_main); + ogg_stream_packetin(&streamout, &header_comments); + ogg_stream_packetin(&streamout, &header_codebooks); + + while((result = ogg_stream_flush(&streamout, &ogout))) + { + if(state->write(ogout.header,1,ogout.header_len, out) != + (size_t) ogout.header_len) + goto cleanup; + if(state->write(ogout.body,1,ogout.body_len, out) != + (size_t) ogout.body_len) + goto cleanup; + } + + while(_fetch_next_packet(state, &op, &ogin)) + { + int size; + size = _blocksize(state, &op); + granpos += size; + + if(needflush) + { + if(ogg_stream_flush(&streamout, &ogout)) + { + if(state->write(ogout.header,1,ogout.header_len, + out) != (size_t) ogout.header_len) + goto cleanup; + if(state->write(ogout.body,1,ogout.body_len, + out) != (size_t) ogout.body_len) + goto cleanup; + } + } + else if(needout) + { + if(ogg_stream_pageout(&streamout, &ogout)) + { + if(state->write(ogout.header,1,ogout.header_len, + out) != (size_t) ogout.header_len) + goto cleanup; + if(state->write(ogout.body,1,ogout.body_len, + out) != (size_t) ogout.body_len) + goto cleanup; + } + } + + needflush=needout=0; + + if(op.granulepos == -1) + { + op.granulepos = granpos; + ogg_stream_packetin(&streamout, &op); + } + else /* granulepos is set, validly. Use it, and force a flush to + account for shortened blocks (vcut) when appropriate */ + { + if(granpos > op.granulepos) + { + granpos = op.granulepos; + ogg_stream_packetin(&streamout, &op); + needflush=1; + } + else + { + ogg_stream_packetin(&streamout, &op); + needout=1; + } + } + } + + streamout.e_o_s = 1; + while(ogg_stream_flush(&streamout, &ogout)) + { + if(state->write(ogout.header,1,ogout.header_len, + out) != (size_t) ogout.header_len) + goto cleanup; + if(state->write(ogout.body,1,ogout.body_len, + out) != (size_t) ogout.body_len) + goto cleanup; + } + + if (state->extrapage) + { + if(state->write(ogin.header,1,ogin.header_len, + out) != (size_t) ogin.header_len) + goto cleanup; + if (state->write(ogin.body,1,ogin.body_len, out) != + (size_t) ogin.body_len) + goto cleanup; + } + + state->eosin=0; /* clear it, because not all paths to here do */ + while(!state->eosin) /* We reached eos, not eof */ + { + /* We copy the rest of the stream (other logical streams) + * through, a page at a time. */ + while(1) + { + result = ogg_sync_pageout(state->oy, &ogout); + if(result==0) + break; + if(result<0) + state->lasterror = "Corrupt or missing data, continuing..."; + else + { + /* Don't bother going through the rest, we can just + * write the page out now */ + if(state->write(ogout.header,1,ogout.header_len, + out) != (size_t) ogout.header_len) { +// fprintf(stderr, "Bumming out\n"); + goto cleanup; + } + if(state->write(ogout.body,1,ogout.body_len, out) != + (size_t) ogout.body_len) { + // fprintf(stderr, "Bumming out 2\n"); + goto cleanup; + } + } + } + buffer = ogg_sync_buffer(state->oy, CHUNKSIZE); + bytes = (int)state->read(buffer,1, CHUNKSIZE, state->in); + ogg_sync_wrote(state->oy, bytes); + if(bytes == 0) + { + state->eosin = 1; + break; + } + } + + +cleanup: + ogg_stream_clear(&streamout); + ogg_packet_clear(&header_comments); + + free(state->mainbuf); + free(state->bookbuf); + state->mainbuf = state->bookbuf = NULL; + + if(!state->eosin) + { + state->lasterror = + "Error writing stream to output. " + "Output stream may be corrupted or truncated."; + return -1; + } + + return 0; +} + diff --git a/Src/Plugins/Input/in_vorbis/vcedit.h b/Src/Plugins/Input/in_vorbis/vcedit.h new file mode 100644 index 00000000..80cc5a6b --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/vcedit.h @@ -0,0 +1,62 @@ +/* This program is licensed under the GNU Library General Public License, version 2, + * a copy of which is included with this program (with filename LICENSE.LGPL). + * + * (c) 2000-2001 Michael Smith <msmith@labyrinth.net.au> + * + * VCEdit header. + * + * last modified: $ID:$ + */ + +#ifndef __VCEDIT_H +#define __VCEDIT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdio.h> +#include <ogg/ogg.h> +#include <vorbis/codec.h> + +typedef size_t (*vcedit_read_func)(void *, size_t, size_t, void *); +typedef size_t (*vcedit_write_func)(const void *, size_t, size_t, void *); + +typedef struct { + ogg_sync_state *oy; + ogg_stream_state *os; + + vorbis_comment *vc; + vorbis_info *vi; + + vcedit_read_func read; + vcedit_write_func write; + + void *in; + long serial; + unsigned char *mainbuf; + unsigned char *bookbuf; + int mainlen; + int booklen; + char *lasterror; + char *vendor; + int prevW; + int extrapage; + int eosin; +} vcedit_state; + +extern vcedit_state * vcedit_new_state(void); +extern void vcedit_clear(vcedit_state *state); +extern vorbis_comment * vcedit_comments(vcedit_state *state); +extern int vcedit_open(vcedit_state *state, FILE *in); +extern int vcedit_open_callbacks(vcedit_state *state, void *in, + vcedit_read_func read_func, vcedit_write_func write_func); +extern int vcedit_write(vcedit_state *state, void *out); +extern char * vcedit_error(vcedit_state *state); + +#ifdef __cplusplus +} +#endif + +#endif /* __VCEDIT_H */ + diff --git a/Src/Plugins/Input/in_vorbis/version.rc2 b/Src/Plugins/Input/in_vorbis/version.rc2 new file mode 100644 index 00000000..b6a16388 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/version.rc2 @@ -0,0 +1,39 @@ + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// +#include "../../../Winamp/buildType.h" +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,79,0,0 + PRODUCTVERSION WINAMP_PRODUCTVER + FILEFLAGSMASK 0x17L +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", "Winamp SA" + VALUE "FileDescription", "Winamp Input Plug-in" + VALUE "FileVersion", "1,79,0,0" + VALUE "InternalName", "Nullsoft Vorbis Decoder" + VALUE "LegalCopyright", "Copyright © 2001-2023 Winamp SA" + VALUE "LegalTrademarks", "Nullsoft and Winamp are trademarks of Winamp SA" + VALUE "OriginalFilename", "in_vorbis.dll" + VALUE "ProductName", "Winamp" + VALUE "ProductVersion", STR_WINAMP_PRODUCTVER + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END diff --git a/Src/Plugins/Input/in_vorbis/wa2.cpp b/Src/Plugins/Input/in_vorbis/wa2.cpp new file mode 100644 index 00000000..3920a0ee --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/wa2.cpp @@ -0,0 +1,1097 @@ +#include "main.h" +#include "genres.h" +#include "decoder.h" +#include "api__in_vorbis.h" +#include "../Winamp/wa_ipc.h" +#include "../nu/Singleton.h" +#include "mkv_vorbis_decoder.h" +#include <shlwapi.h> +#include "../nu/AutoWide.h" +#include "../nu/AutoChar.h" +#include <strsafe.h> +#include <api/service/waservicefactory.h> + +template <class api_T> +void ServiceBuild(api_T *&api_t, GUID factoryGUID_t) +{ + if (mod.service) + { + waServiceFactory *factory = mod.service->service_getServiceByGuid(factoryGUID_t); + if (factory) + api_t = reinterpret_cast<api_T *>( factory->getInterface() ); + } +} + +template <class api_T> +void ServiceRelease(api_T *api_t, GUID factoryGUID_t) +{ + if (mod.service && api_t) + { + waServiceFactory *factory = mod.service->service_getServiceByGuid(factoryGUID_t); + if (factory) + factory->releaseInterface(api_t); + } + api_t = NULL; +} + +VorbisFile * theFile = 0; + +extern CfgInt cfg_abr,cfg_httpseek2; + +OSVERSIONINFO os_ver = {0}; + +static int pos_ms; +static int seek_to=-1; +static int length; +static bool kill; + +StringW stat_disp; + +void show_stat(const wchar_t* txt) +{ + if (txt) + { + stat_disp=txt; + PostMessage(mod.hMainWindow,WM_USER,0,243); + } + else + stat_disp=L""; +} + +static int is_out_open; +static int paused; +static int volume=255; +static int pan=0; +StringW cur_file; + +CRITICAL_SECTION sync; + +HANDLE hThread=0; + +void Config(HWND); +void About(HWND p); +void do_cfg(int s); +void GetFileInfo(const in_char *file, wchar_t *title, int *len); + +const char *INI_FILE=0; +const wchar_t *INI_DIRECTORY=0; +int (*warand)()=0; +float (*warandf)()=0; + +api_application *WASABI_API_APP = 0; +// wasabi based services for localisation support +api_language *WASABI_API_LNG = 0; +HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST = 0; +api_memmgr* WASABI_API_MEMMGR = 0; +api_config *AGAVE_API_CONFIG=0; + +static MKVDecoderCreator mkvCreator; +static SingletonServiceFactory<svc_mkvdecoder, MKVDecoderCreator> mkvFactory; + +void SetFileExtensions(void) +{ + static char fileExtensionsString[1200] = {0}; // "OGG\0Ogg files (*.OGG)\0" + char* end = 0; + StringCchCopyExA(fileExtensionsString, 1200, "OGG;OGA", &end, 0, 0); + StringCchCopyExA(end+1, 1200, WASABI_API_LNGSTRING(IDS_OGG_FILES), 0, 0, 0); + mod.FileExtensions = fileExtensionsString; +} + +int Init() +{ + if (!IsWindow(mod.hMainWindow)) + return IN_INIT_FAILURE; + + mod.UsesOutputPlug|=8; + + warand = (int (*)())SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GET_RANDFUNC); + warandf = (float (*)())SendMessage(mod.hMainWindow, WM_WA_IPC, 1, IPC_GET_RANDFUNC); + + ServiceBuild(WASABI_API_MEMMGR, memMgrApiServiceGuid); + ServiceBuild(AGAVE_API_CONFIG, AgaveConfigGUID); + // loader so that we can get the localisation service api for use + ServiceBuild(WASABI_API_LNG, languageApiGUID); + ServiceBuild(WASABI_API_APP, applicationApiServiceGuid); + + mkvFactory.Register(mod.service, &mkvCreator); + + // need to have this initialised before we try to do anything with localisation features + WASABI_API_START_LANG(mod.hDllInstance,InVorbisLangGUID); + + static wchar_t szDescription[256]; + StringCchPrintfW(szDescription,256,WASABI_API_LNGSTRINGW(IDS_NULLSOFT_VORBIS_DECODER),VER); + mod.description = (char*)szDescription; + + SetFileExtensions(); + + INI_FILE = (const char *)SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GETINIFILE); + INI_DIRECTORY = (const wchar_t *)SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GETINIDIRECTORYW); + + os_ver.dwOSVersionInfoSize=sizeof(os_ver); + GetVersionEx(&os_ver); + + InitializeCriticalSection(&sync); + do_cfg(0); + return IN_INIT_SUCCESS; +} + +void Quit() +{ + winampGetExtendedFileInfoW_Cleanup(); + DeleteCriticalSection(&sync); + mkvFactory.Deregister(mod.service); + ServiceRelease(WASABI_API_MEMMGR, memMgrApiServiceGuid); + ServiceRelease(AGAVE_API_CONFIG, AgaveConfigGUID); + ServiceRelease(WASABI_API_LNG, languageApiGUID); + ServiceRelease(WASABI_API_APP, applicationApiServiceGuid); +} + +int GetLength() +{ + return length; +} + +int IsOurFile(const in_char *fn) +{ + if (PathIsURLW(fn)) + { + const wchar_t *foo=wcsrchr(fn,L'.'); + return foo ? !_wcsicmp(foo,L".ogg") : 0; + } + else return 0; +} + +static UINT kbps_disp; + +static void out_close() +{ + if (is_out_open) + { + mod.outMod->Close(); + mod.SAVSADeInit(); + is_out_open=0; + } +} + +static bool need_full_setinfo; + +static int out_open(const Decoder &dec) +{ + int max_l=mod.outMod->Open(dec.sr,dec.nch,dec.bps,-1,-1); + if (max_l<0) return 0; + mod.outMod->SetVolume(-666); + mod.outMod->SetPan(pan); + mod.SAVSAInit(max_l,dec.sr); + mod.VSASetInfo(dec.sr,dec.nch); + + is_out_open=1; + need_full_setinfo=1; + return 1; +} + +void Decoder::wa2_setinfo(UINT cur) +{ + UINT disp=file->get_avg_bitrate(); + if (!cfg_abr) + { + disp=cur; + } + if ((disp && disp!=kbps_disp) || need_full_setinfo) + { + kbps_disp=disp; + if (need_full_setinfo) + { + mod.SetInfo(disp,sr/1000,nch,1); + need_full_setinfo=0; + } + else mod.SetInfo(disp,-1,-1,1); + } +} + +static bool need_movefile; +static void process_movefile(); + +void alloc_buffers(Decoder & dec,short ** visbuf,char ** sample_buf,int * s_size) +{ + *s_size=576 * (dec.bps>>3) * dec.nch; + + if (*sample_buf) *sample_buf=(char*)realloc(*sample_buf,*s_size*2); + else *sample_buf=(char*)malloc(*s_size*2); + + if (dec.bps>16) + { + int vs=576*2*dec.nch; + if (*visbuf) *visbuf=(short*)realloc(*visbuf,vs); + else *visbuf=(short*)malloc(vs); + } + else if (*visbuf) {free(*visbuf);*visbuf=0;} +} + +static DWORD WINAPI PlayThread(Decoder &dec) +{ + int pos_base=0; + int samp_wr=0; + int done=0; + int upd=0; + __int64 brate; + int br_div,br_t; + short* visbuf=0; + char *sample_buf=0; + int retries=0; + int s_size=0; + + pos_ms=0; + + { + int r; + r=dec.play_init(); + if (r) + { + if (!kill) Sleep(50); + if (!kill) Sleep(50); + if (!kill) Sleep(50); + if (!kill) Sleep(50); + if (!kill) + { + if (r==2) PostMessage(mod.hMainWindow,WM_WA_MPEG_EOF,0,0); + else PostMessage(mod.hMainWindow,WM_COMMAND,40047,0); + } + delete &dec; + return 0; + } + theFile->do_prebuf(); + } + + brate=0; + br_div=0; + upd=0; + + alloc_buffers(dec,&visbuf,&sample_buf,&s_size); + + //int f_type=theFile->GetType(); + bool is_live=theFile->IsLive(); + + while(!kill) + { + if (!theFile) break;//ugh + if (seek_to!= -1) + { + UINT _st=seek_to; + int r=1; + seek_to=-1; + if (theFile) + { + theFile->use_prebuf=0; + int link=theFile->vf.current_link; + r=dec.Seek((double)_st*0.001); + if (link!=theFile->vf.current_link) PostMessage(mod.hMainWindow,WM_USER,0,243); + } + else r=1; + if (!r) + { + pos_base=pos_ms=_st; + mod.outMod->Flush(pos_ms); + samp_wr=0; + done=0; + theFile->do_prebuf(); + } + } + + if (need_movefile && paused)//HACK, prevent stupid lockup + { + process_movefile(); + if (!theFile) break;//#@! + dec.file=theFile; + dec.Flush(); + } + + if (done) + { + // mod.outMod->CanWrite(); + if (!mod.outMod->IsPlaying()) + { + PostMessage(mod.hMainWindow,WM_WA_MPEG_EOF,0,0); + break; + } + Sleep(10); + } + else if (mod.outMod->CanWrite() >= (s_size<<(mod.dsp_isactive()?1:0))) + { + int l=0; + while(1) + { + if (!dec.need_reopen) + { + l+=dec.Read(s_size-l,sample_buf+l); + if (l>=s_size) break; + + int link=theFile->vf.current_link; + if (need_movefile)//safe not to flush here + { + process_movefile(); + if (!theFile) break;//#@! + dec.file=theFile; + } + if (!dec.DoFrame()) break; + if (kill) break; + + if (link!=theFile->vf.current_link) + { + PostMessage(mod.hMainWindow,WM_USER,0,243); + } + br_t=ov_bitrate_instant(&theFile->vf); + if (br_t>0) + { + int i = dec.DataAvailable()/((dec.bps/8)*dec.nch); + br_div+=i; + brate+=(__int64)(br_t*i); + } + if (need_full_setinfo || (!((++upd)%200) && br_div)) + { + if (!br_div) {br_div=1;brate=theFile->get_avg_bitrate();} + dec.wa2_setinfo((int)((__int64)brate/(__int64)br_div/(__int64)1000)); + brate=0; + br_div=0; + } + } + if (dec.need_reopen) + {//blargh, new PCM format + if (l>0) break;//got samples to play, we'll deal with this later + //l=0; + while(!kill && mod.outMod->IsPlaying()) Sleep(1); + if (kill) break; + out_close(); + if (!out_open(dec))//boo + { + PostMessage(mod.hMainWindow,WM_COMMAND,40047,0); + kill=1; + break; + } + alloc_buffers(dec,&visbuf,&sample_buf,&s_size); + dec.need_reopen=0; + } + } + + if (kill || !theFile) break; + + if (l<=0 && (!is_live || (--retries)<0)) + { + mod.outMod->Write(sample_buf,0); + done=1; + } + else if (l<=0) + { + int r; + out_close(); + EnterCriticalSection(&sync); + delete theFile; + theFile=0; + LeaveCriticalSection(&sync); + if (sample_buf) + { + free(sample_buf); + sample_buf=0; + } + + r=dec.play_init(); + + if (r) + { + mod.outMod->Write(sample_buf,0); + done=1; + } + else + { + theFile->do_prebuf(); + } + } + else + { + if (l<s_size) memset(sample_buf+l,dec.bps==8 ? 0x80 : 0,s_size-l); + char * vis=sample_buf; + UINT vis_bps=dec.bps; + if (dec.bps>16) + { + UINT n; + UINT d=dec.bps>>3; + char * foo=sample_buf+d-2; + for(n=0;n<576*dec.nch;n++) + { + visbuf[n]=*(short*)foo; + foo+=d; + } + vis=(char*)visbuf; + vis_bps=16; + } + mod.SAAddPCMData(vis,dec.nch,vis_bps,pos_ms); + mod.VSAAddPCMData(vis,dec.nch,vis_bps,pos_ms); + + if (mod.dsp_isactive()) + { + l=(l<<3)/(dec.bps*dec.nch); + l=mod.dsp_dosamples((short*)sample_buf,l,dec.bps,dec.nch,dec.sr); + l*=(dec.nch*dec.bps)>>3; + } + if (kill) break; + mod.outMod->Write((char*)sample_buf,l); + + samp_wr+=(8*l)/(dec.bps*dec.nch); + pos_ms=pos_base+MulDiv(1000,samp_wr,dec.sr); + } + } + else + { + theFile->Idle(); + } + } + + // out_close(); + // gay gapless plugins puke, need to call this from stop + // ok, hetero (out_wave v2.x / out_ds v1.4+) gapless plugins wouldn't puke anymore + + if (theFile) + { + VorbisFile * t=theFile; + EnterCriticalSection(&sync); + theFile=0; + LeaveCriticalSection(&sync); + delete t; + } + + if (sample_buf) + { + free(sample_buf); + sample_buf=0; + } + + if (need_movefile) process_movefile(); + + /* if (!kill) + { + CloseHandle(hThread); + hThread=0; + }*/ + + if (visbuf) free(visbuf); + + delete &dec; + return 0; +} + +static StringW move_src,move_dst; +static bool mf_ret; + +static void do_movefile() +{ + mf_ret=1; + winampGetExtendedFileInfoW_Cleanup(); + if (!DeleteFileW(move_dst)) mf_ret=0; + else + { + if (!MoveFileW(move_src,move_dst)) + { + if (!CopyFileW(move_src,move_dst,0)) mf_ret=0; + DeleteFileW(move_src); + } + } +} + +static void process_movefile() +{ + if (theFile) + { + StringW f_path; + f_path.AddString(theFile->url); + double pos=theFile->GetPos(); + EnterCriticalSection(&sync); + delete theFile; + theFile=0; + + do_movefile(); + + theFile=VorbisFile::Create(f_path,0); + LeaveCriticalSection(&sync); + if (theFile) + { + theFile->Seek(pos); + } + } + else do_movefile(); + need_movefile=0; +} + +bool sync_movefile(const wchar_t * src,const wchar_t * dst)//called from info_.cpp +{ + move_src=src; + move_dst=dst; + need_movefile=1; + if (!theFile) process_movefile(); + else + { + while(need_movefile && hThread) Sleep(1); + if (need_movefile) process_movefile();//shouldnt really happen + move_src=L""; + move_dst=L""; + PostMessage(mod.hMainWindow,WM_USER,0,243); + } + + return mf_ret; +} + + +int Decoder::play_init()//still messy +{ + if (play_inited) return 0; + + kbps_disp=0; + + VorbisFile * t=VorbisFile::Create(cur_file,0); + if (!t) + { +#ifdef _DEBUG + OutputDebugString(L"can't open file\n"); +#endif + // if (scream) MessageBox(mod.hMainWindow,"error opening file",0,MB_ICONERROR); + return 2; + } + Init(t); + if (!out_open(*this)) + { +#ifdef _DEBUG + OutputDebugString(L"can't open output\n"); +#endif + delete t; + return 1; + } + + EnterCriticalSection(&sync); + theFile=t; + LeaveCriticalSection(&sync); + + wa2_setinfo(theFile->get_avg_bitrate()); + + { + double v=theFile->Length(); + if (v==OV_EINVAL || v<=0) length=-1; + else length=(int)(v*1000.0); + } + + play_inited=1; + + return 0; +} + +int Play(const in_char *fn) +{ + seek_to=-1; + kill=0; + length=0; + paused=0; + + show_stat(0); + + EnterCriticalSection(&sync); + cur_file=fn; + LeaveCriticalSection(&sync); + + Decoder * dec=new Decoder; + + if (!PathIsURLW(fn)) + { + mod.is_seekable=1; +#if 1 + int rv=dec->play_init(); + if (rv) + { + delete dec; + if (rv==2) return -1; + return 1; + } +#endif + } + else mod.is_seekable=cfg_httpseek2; + + { + DWORD id; + hThread=CreateThread(0,0,(LPTHREAD_START_ROUTINE)PlayThread,dec,CREATE_SUSPENDED,&id); + } + + if (hThread) + { + SetThreadPriority(hThread, (int)AGAVE_API_CONFIG->GetInt(playbackConfigGroupGUID, L"priority", THREAD_PRIORITY_HIGHEST)); + ResumeThread(hThread); + return 0; + } + else + { + out_close(); + delete dec; + return 1; + } +} + +void Pause() +{ + if (!paused) + { + mod.outMod->Pause(1); + paused=1; + } +} + +void UnPause() +{ + if (paused) + { + mod.outMod->Pause(0); + paused=0; + } +} + +int IsPaused() +{ + return paused; +} + +void Stop() +{ + if (hThread) + { + kill=1; + EnterCriticalSection(&sync); + if (theFile) theFile->stopping=1; + LeaveCriticalSection(&sync); + if (WaitForSingleObject(hThread,10000)!=WAIT_OBJECT_0) + { + TerminateThread(hThread,0); + //MessageBox(mod.hMainWindow,"error asking thread to die",0,MB_ICONERROR); + } + CloseHandle(hThread); + hThread=0; + out_close(); + } + show_stat(0); + winampGetExtendedFileInfoW_Cleanup(); +} + +void EQSet(int on, char data[10], int preamp) +{ +} + +int GetOutputTime() +{ + return pos_ms+(mod.outMod->GetOutputTime()-mod.outMod->GetWrittenTime()); +} + +void SetOutputTime(int t) +{ + seek_to=t; + EnterCriticalSection(&sync); + if (theFile) theFile->abort_prebuf=1; + LeaveCriticalSection(&sync); +} + +void SetVolume(int v) +{ + mod.outMod->SetVolume(volume=v); +} + +void SetPan(int p) +{ + mod.outMod->SetPan(pan=p); +} + +//int InfoBox(char *file, HWND parent); //old +int RunInfoDlg(const in_char * url,HWND parent); + +In_Module mod= +{ + IN_VER_RET, + "nullsoft(in_vorbis.dll)", + 0,0, + 0, + 1, + 1, + + Config, + About, + + Init, + Quit, + + GetFileInfo, + RunInfoDlg, + + IsOurFile, + Play, + Pause, + UnPause, + IsPaused, + Stop, + + GetLength, + GetOutputTime, + SetOutputTime, + + SetVolume, + SetPan, + + 0,0,0,0,0,0,0,0,0,0,0, + EQSet, + + 0, + 0, +}; + +extern "C" { + __declspec( dllexport ) In_Module * winampGetInModule2() + { + return &mod; + } +} + +void VorbisFile::Status(const wchar_t * zzz) +{ + if (primary) + show_stat(zzz); +} + +bool VorbisFile::Aborting() +{ + return stopping || (primary && kill); +} + + +Info::Info(const wchar_t *filename) : filename(filename), vc(0) +{ + VorbisFile * vf = VorbisFile::Create(filename,true); + if(!vf) + return; + + numstreams = vf->vf.links; + if(numstreams) + { + // now copy the comment section to our own memory... + stream = vf->vf.current_link; // this is the stream we're editing... + vc = (vorbis_comment*)calloc(sizeof(vorbis_comment),numstreams); + + for(int i=0; i<numstreams; i++) + { // one comment section per stream + vorbis_comment *c = ov_comment(&vf->vf,i); + + vc[i].comments = c->comments; + vc[i].user_comments = (char **)malloc(sizeof(char*)*c->comments); + vc[i].comment_lengths = (int *)malloc(sizeof(int)*c->comments); + + for(int j=0;j<vc[i].comments;j++) + { // copy the comments over + vc[i].user_comments[j] = _strdup(c->user_comments[j]); + vc[i].comment_lengths[j] = c->comment_lengths[j]; + } + vc[i].vendor=_strdup(c->vendor); + } + } + delete vf; +} + +Info::~Info() +{ + if(vc) { + for(int i=0; i < numstreams; i++) + vorbis_comment_clear(&vc[i]); + free(vc); + } +} + +bool Info::Save() +{ + return !!modify_file(filename,vc,numstreams); +} + +int Info::GetNumMetadataItems() +{ + return vc[stream].comments; +} + +void Info::EnumMetadata(int n, wchar_t *key, int keylen, wchar_t *val, int vallen) +{ + if(keylen) key[0]=0; + if(vallen) val[0]=0; + if(!vc) return; + if(!vc[stream].user_comments[n]) return; + AutoWide comment(vc[stream].user_comments[n],CP_UTF8); + const wchar_t* eq = wcschr((const wchar_t*)comment,L'='); + if(eq) + { + if(keylen) lstrcpynW(key,comment,(int)min(eq - comment + 1,keylen)); + if(vallen) lstrcpynW(val,eq+1,vallen); + } + else + { + if(keylen) lstrcpynW(key,L"COMMENT",keylen); + if(vallen) lstrcpynW(val,comment,vallen); + } +} + +void Info::RemoveMetadata(wchar_t * key) +{ + wchar_t k[256] = {0}; + for(int i=0; i<GetNumMetadataItems(); i++) + { + EnumMetadata(i,k,256,0,0); + if(_wcsicmp(k,key)==0) + RemoveMetadata(i); + } +} + +void Info::RemoveMetadata(int n) +{ + if(!vc) return; + free(vc[stream].user_comments[n]); + + for(int i=n+1; i<vc[stream].comments; i++) + { + vc[stream].user_comments[i-1] = vc[stream].user_comments[i]; + if(vc[stream].comment_lengths) + vc[stream].comment_lengths[i-1] = vc[stream].comment_lengths[i]; + } + vc[stream].comments--; + vc[stream].user_comments = (char**)realloc(vc[stream].user_comments,sizeof(vc[stream].user_comments[0]) * vc[stream].comments); + if(vc[stream].comment_lengths) + vc[stream].comment_lengths = (int*)realloc(vc[stream].comment_lengths,sizeof(vc[stream].comment_lengths[0]) * vc[stream].comments); +} + +void Info::SetMetadata(wchar_t *key, wchar_t *val) +{ + bool set=false; + wchar_t k[256] = {0}; + for(int i=0; i<GetNumMetadataItems(); i++) + { + EnumMetadata(i,k,256,0,0); + if(_wcsicmp(k,key)==0) + { + SetMetadata(i,key,val); + set=true; + } + } + if(!set) + { + int n = vc[stream].comments++; + vc[stream].user_comments = (char**)realloc(vc[stream].user_comments,sizeof(vc[stream].user_comments[0]) * vc[stream].comments); + if(vc[stream].comment_lengths) + vc[stream].comment_lengths = (int*)realloc(vc[stream].comment_lengths,sizeof(vc[stream].comment_lengths[0]) * vc[stream].comments); + vc[stream].user_comments[n] = NULL; + SetMetadata(n,key,val); + } +} + +void Info::SetMetadata(int n, wchar_t *key, wchar_t *val) +{ + AutoChar k(key,CP_UTF8); + AutoChar v(val,CP_UTF8); + + int l = (int)(strlen(k)+strlen(v)+2); + char * c = (char*)malloc(l); + StringCchPrintfA(c,l,"%s=%s",(char*)k,(char*)v); + + if(vc[stream].user_comments[n]) + free(vc[stream].user_comments[n]); + + vc[stream].user_comments[n] = c; + if(vc[stream].comment_lengths) + vc[stream].comment_lengths[n] = l-1; +} + +void Info::SetTag(int n,wchar_t *key) // changes the key name +{ + wchar_t val[2048] = {0}; + EnumMetadata(n,NULL,0,val,2048); + SetMetadata(n,key,val); +} + +Info *setMetadata = 0; + +extern "C" +{ + static wchar_t m_lastfn[2048]; + + #define START_TAG_ALIAS(name, alias) if (KeywordMatch(data, name)) lookup=alias + #define TAG_ALIAS(name, alias) else if (KeywordMatch(data, name)) lookup=alias + + __declspec( dllexport ) int winampSetExtendedFileInfoW(const wchar_t *fn, const char *data, wchar_t *val) + { + if (!setMetadata || setMetadata && wcscmp(fn,m_lastfn)) + { + if (setMetadata) + { + delete setMetadata; + setMetadata = 0; + } + + setMetadata = new Info(fn); + if(setMetadata->Error()) + { + delete setMetadata; + m_lastfn[0] = 0; + return 0; + } + lstrcpynW(m_lastfn,fn, 2048); + } + + wchar_t *lookup=0; + START_TAG_ALIAS("artist", L"ARTIST"); + TAG_ALIAS("title", L"TITLE"); + TAG_ALIAS("album", L"ALBUM"); + TAG_ALIAS("genre", L"GENRE"); + TAG_ALIAS("comment", L"COMMENT"); + TAG_ALIAS("year", L"DATE"); + TAG_ALIAS("track", L"TRACKNUMBER"); + TAG_ALIAS("albumartist", L"ALBUM ARTIST"); + TAG_ALIAS("composer", L"COMPOSER"); + TAG_ALIAS("disc", L"DISCNUMBER"); + TAG_ALIAS("publisher", L"PUBLISHER"); + TAG_ALIAS("conductor", L"CONDUCTOR"); + TAG_ALIAS("tool", L"ENCODED-BY"); + TAG_ALIAS("replaygain_track_gain", L"REPLAYGAIN_TRACK_GAIN"); + TAG_ALIAS("replaygain_track_peak", L"REPLAYGAIN_TRACK_PEAK"); + TAG_ALIAS("replaygain_album_gain", L"REPLAYGAIN_ALBUM_GAIN"); + TAG_ALIAS("replaygain_album_peak", L"REPLAYGAIN_ALBUM_PEAK"); + TAG_ALIAS("GracenoteFileID", L"GRACENOTEFILEID"); + TAG_ALIAS("GracenoteExtData", L"GRACENOTEEXTDATA"); + TAG_ALIAS("bpm", L"BPM"); + TAG_ALIAS("remixing", L"REMIXING"); + TAG_ALIAS("subtitle", L"VERSION"); + TAG_ALIAS("isrc", L"ISRC"); + TAG_ALIAS("category", L"CATEGORY"); + TAG_ALIAS("rating", L"RATING"); + TAG_ALIAS("producer", L"PRODUCER"); + + if (!lookup) + return 0; + +#if 0 + if (val && *val) + { + if(KeywordMatch("rating",data)) + { + wchar_t temp[128] = {0}; + StringCchPrintfW(temp, 128, L"%u", _wtoi(val)*20); + val=temp; + } + } + AutoChar utf8(val, CP_UTF8); + + for(int i=0;i<m_vc->comments;i++) + { + char *c=m_vc[m_curstream].user_comments[i]; + if(!c) continue; + char *p=strchr(c,'='); + if (p && *p) + { + if(strlen(data) == (p-c) && !_strnicmp(c,data,p-c)) + { + //found! + if (val && val[0]) + { + int added_buf_len = strlen(utf8)+strlen(lookup)+2; + m_vc[m_curstream].user_comments[i]=(char *)realloc(m_vc[m_curstream].user_comments[i],added_buf_len); + StringCchPrintfA(m_vc[m_curstream].user_comments[i],added_buf_len,"%s=%s",lookup,(char *)utf8); + m_vc[m_curstream].comment_lengths[i]=strlen(m_vc[m_curstream].user_comments[i]); + } + else + { + free(m_vc[m_curstream].user_comments[i]); + m_vc[m_curstream].user_comments[i]=0; + m_vc[m_curstream].comment_lengths[i]=0; + } + return 1; + } + } + } + + //not found, so create new field + if (val && val[0]) + { + int k=m_vc[m_curstream].comments++; + m_vc[m_curstream].user_comments=(char **)realloc(m_vc[m_curstream].user_comments,sizeof(char*)*m_vc[m_curstream].comments); + m_vc[m_curstream].comment_lengths=(int *)realloc(m_vc[m_curstream].comment_lengths,sizeof(int)*m_vc[m_curstream].comments); + int added_buf_len = strlen(utf8)+strlen(lookup)+2; + m_vc[m_curstream].user_comments[k]=(char *)malloc(added_buf_len); + StringCchPrintfA(m_vc[m_curstream].user_comments[k],added_buf_len,"%s=%s",lookup,(char *)utf8); + m_vc[m_curstream].comment_lengths[k]=strlen(m_vc[m_curstream].user_comments[k]); + } +#endif + + if (val && *val) + { + if(KeywordMatch("rating",data)) + { + wchar_t temp[128] = {0}; + StringCchPrintfW(temp, 128, L"%u", _wtoi(val)*20); + setMetadata->SetMetadata(lookup, temp); + } + else + { + setMetadata->SetMetadata(lookup, val); + } + } + else + { + setMetadata->RemoveMetadata(lookup); + if(KeywordMatch("comment",data)) + { + // need to remove this one also, or else it's gonna look like delete doesn't work + // if the file was tagged using this alternate field + setMetadata->RemoveMetadata(L"DESCRIPTION"); + } + else if(KeywordMatch("year",data)) + { + // need to remove this one also, or else it's gonna look like delete doesn't work + // if the file was tagged using this alternate field + setMetadata->RemoveMetadata(L"YEAR"); + } + else if(KeywordMatch("track",data)) + { + // need to remove this one also, or else it's gonna look like delete doesn't work + // if the file was tagged using this alternate field + setMetadata->RemoveMetadata(L"TRACK"); + } + else if(KeywordMatch("albumartist",data)) + { + // need to remove these two, also, or else it's gonna look like delete doesn't work + // if the file was tagged using these alternate fields + setMetadata->RemoveMetadata(L"ALBUMARTIST"); + setMetadata->RemoveMetadata(L"ENSEMBLE"); + } + else if(KeywordMatch("publisher",data)) + { + // need to remove this one also, or else it's gonna look like delete doesn't work + // if the file was tagged using this alternate field + setMetadata->RemoveMetadata(L"ORGANIZATION"); + } + else if(KeywordMatch("category",data)) + { + // need to remove these two also, or else it's gonna look like delete doesn't work + // if the file was tagged using these alternate fields + setMetadata->RemoveMetadata(L"CONTENTGROUP"); + setMetadata->RemoveMetadata(L"GROUPING"); + } + } + + return 1; + } + + __declspec( dllexport ) int winampWriteExtendedFileInfo() + { + if(!setMetadata) return 0; + + bool ret = setMetadata->Save(); + delete setMetadata; + setMetadata = 0; + + // update last modified so we're not re-queried on our own updates + UpdateFileTimeChanged(m_lastfn); + + return ret; + } +}
\ No newline at end of file diff --git a/Src/Plugins/Input/in_vorbis/winnt_helper.cpp b/Src/Plugins/Input/in_vorbis/winnt_helper.cpp new file mode 100644 index 00000000..da44ca42 --- /dev/null +++ b/Src/Plugins/Input/in_vorbis/winnt_helper.cpp @@ -0,0 +1,2 @@ +#include "main.h" +#include "api__in_vorbis.h" |
