steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Library/ml_pmp/transcoder_imp.cpp

539 lines
15 KiB
C++
Raw Permalink Blame History

#include "api__ml_pmp.h"
#include "transcoder_imp.h"
#include "nu/ns_wc.h"
#include <shlwapi.h>
#include <strsafe.h>
#include <mmiscapi.h>
extern HWND CreateDummyWindow();
static std::vector<TranscoderImp*> transcoders;
LRESULT CALLBACK TranscodeMsgProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if ( uMsg == WM_WA_IPC && ( lParam == IPC_CB_CONVERT_STATUS || lParam == IPC_CB_CONVERT_DONE ) )
{
for ( TranscoderImp *t : transcoders )
{
if ( t->cfs.callbackhwnd == hwnd )
{
t->TranscodeProgress( (int)wParam, lParam == IPC_CB_CONVERT_DONE );
break;
}
}
}
return 0;
}
static void fourccToString(unsigned int f, wchar_t * str) {
wchar_t s[4] = {(wchar_t)(f&0xFF),(wchar_t)((f>>8)&0xFF),(wchar_t)((f>>16)&0xFF),0};
wcsncpy(str,s,4);
CharLower(str);
}
static unsigned int stringToFourcc(const wchar_t * str) {
FOURCC cc = 0;
char *ccc = (char *)&cc;
// unrolled loop (this function gets called a lot on sync and autofill)
if (str[0])
{
ccc[0] = (char)str[0];
if (str[1])
{
ccc[1] = (char)str[1];
if (str[2])
{
ccc[2] = (char)str[2];
if (str[3])
{
ccc[3] = (char)str[3];
}
}
}
}
CharUpperBuffA(ccc, 4);
return cc;
}
static bool fourccEqual(unsigned int a, unsigned int b) {
if((a & 0xFF000000) == 0 || (b & 0xFF000000) == 0)
return (a & 0x00FFFFFF) == (b & 0x00FFFFFF);
return a == b;
}
class TranscodeProfileCache {
public:
unsigned int inputformat;
unsigned int outputformat;
int outputbitrate;
TranscodeProfileCache(unsigned int inputformat,unsigned int outputformat,int outputbitrate) :
inputformat(inputformat), outputformat(outputformat),outputbitrate(outputbitrate){}
};
static void enumProc(intptr_t user_data, const char *desc, int fourcc)
{
((FormatList *)user_data)->push_back(new EncodableFormat((unsigned int)fourcc,AutoWide(desc)));
}
static void BuildEncodableFormatsList(FormatList &list, HWND winampWindow, Device *device)
{
converterEnumFmtStruct e = {enumProc,(intptr_t)&list};
SendMessage(winampWindow,WM_WA_IPC,(WPARAM)&e,IPC_CONVERT_CONFIG_ENUMFMTS);
// filter out unacceptable formats
int i = list.size();
while (i--)
{
if (device && device->extraActions(DEVICE_VETO_ENCODER, list[i]->fourcc, 0, 0) == 1)
{
list.erase(list.begin() + i);
}
}
}
static CRITICAL_SECTION csTranscoder;
void TranscoderImp::init() {
InitializeCriticalSection(&csTranscoder);
}
void TranscoderImp::quit() {
DeleteCriticalSection(&csTranscoder);
}
TranscoderImp::TranscoderImp(HWND winampParent, HINSTANCE hInst, C_Config * config, Device *device)
: device(device), config(config), winampParent(winampParent), hInst(hInst)
{
EnterCriticalSection(&csTranscoder);
transratethresh = config->ReadInt(L"forcetranscodingbitrate",250);
transrate = !!config->ReadInt(L"transrate",0);
translossless = !!config->ReadInt(L"translossless",0);
TranscoderDisabled = !config->ReadInt(L"enableTranscoder",1);
int current_fourcc = config->ReadInt(L"lastusedencoder", 0);
if (current_fourcc == 0)
{
// TODO: ask for default from plugin
config->WriteInt(L"lastusedencoder", ' A4M');
}
WASABI_API_LNGSTRINGW_BUF(IDS_TRANSFER_PERCENT,caption,100);
ZeroMemory(&cfs,sizeof(convertFileStruct));
this->callback = NULL;
transcoders.push_back(this);
callbackhwnd = CreateDummyWindow();
StringCchCopy(inifile, ARRAYSIZE(inifile), config->GetIniFile());
WideCharToMultiByteSZ(CP_ACP, 0, inifile, -1, inifileA, MAX_PATH, 0, 0);
BuildEncodableFormatsList(formats, winampParent, device);
LeaveCriticalSection(&csTranscoder);
}
TranscoderImp::~TranscoderImp()
{
EnterCriticalSection(&csTranscoder);
//transcoders.eraseObject(this);
auto it = std::find(transcoders.begin(), transcoders.end(), this);
if (it != transcoders.end())
{
transcoders.erase(it);
}
//formats.deleteAll();
for (auto format : formats)
{
delete format;
}
formats.clear();
DestroyWindow(callbackhwnd);
LeaveCriticalSection(&csTranscoder);
}
void TranscoderImp::LoadConfigProfile(wchar_t *profile) {
}
void TranscoderImp::ReloadConfig()
{
//formats.deleteAll();
for (auto format : formats)
{
delete format;
}
formats.clear();
BuildEncodableFormatsList(formats, winampParent, device);
transratethresh = config->ReadInt(L"forcetranscodingbitrate",250);
transrate = !!config->ReadInt(L"transrate",0);
translossless = !!config->ReadInt(L"translossless",0);
TranscoderDisabled = !config->ReadInt(L"enableTranscoder",1);
}
void TranscoderImp::AddAcceptableFormat(unsigned int format)
{
outformats.push_back(format);
}
void TranscoderImp::AddAcceptableFormat(wchar_t *format)
{
outformats.push_back(stringToFourcc(format));
}
static bool FileExists(const wchar_t *file)
{
return GetFileAttributesW(file) != INVALID_FILE_ATTRIBUTES;
}
static int getFileLength(const wchar_t * file, HWND winampParent) { // returns length in seconds
basicFileInfoStructW b={0};
b.filename=file;
SendMessage(winampParent,WM_WA_IPC,(WPARAM)&b,IPC_GET_BASIC_FILE_INFOW);
return b.length;
}
static bool isFileLossless(const wchar_t * file) {
wchar_t ret[64] = {0};
if (AGAVE_API_METADATA && AGAVE_API_METADATA->GetExtendedFileInfo(file, L"lossless", ret, 64) && ret[0] == '1')
return true;
return false;
}
static int getFileBitrate(const wchar_t * file, HWND winampParent) { // returns bitrate in bits per second.
int secs = getFileLength(file,winampParent);
if(!secs) return 0;
FILE * f = _wfopen(file,L"rb");
int len = 0;
if(f) { fseek(f,0,2); len=ftell(f); fclose(f); }
return (len/secs)*8;
}
void TranscoderImp::GetTempFilePath(const wchar_t *ext, wchar_t *path) {
wchar_t dir[MAX_PATH] = {0};
GetTempPath(MAX_PATH,dir);
GetTempFileName(dir,L"transcode",0,path);
_wunlink(path);
wchar_t *e = wcsrchr(path,L'.');
if(e) *e=0;
wcscat(path,ext);
_wunlink(path);
}
void TranscoderImp::TranscodeProgress(int pc, bool done) {
if(!done) {
wchar_t buf[128] = {0};
StringCchPrintf(buf, ARRAYSIZE(buf), caption,pc);
if(callback) callback(callbackContext,buf);
}
else convertDone = done;
}
bool TranscoderImp::StartTranscode(unsigned int destformat, wchar_t *inputFile, wchar_t *outputFile, bool test) {
cfs.callbackhwnd = callbackhwnd;
cfs.sourcefile = _wcsdup(inputFile);
cfs.destfile = _wcsdup(outputFile);
cfs.destformat[0] = destformat;
cfs.destformat[6] = mmioFOURCC('I','N','I',' ');
cfs.destformat[7] = (intptr_t)inifileA;
cfs.error = L"";
if(!SendMessage(winampParent,WM_WA_IPC,(WPARAM)&cfs,IPC_CONVERTFILEW))
{
if(cfs.error && callback)
callback(callbackContext,cfs.error);
return false;
}
if(!test)
{
convertSetPriorityW csp = {&cfs,THREAD_PRIORITY_NORMAL};
SendMessage(winampParent, WM_WA_IPC, (WPARAM)&csp, IPC_CONVERT_SET_PRIORITYW);
TranscodeProgress(0,false);
}
return true;
}
void TranscoderImp::EndTranscode()
{
cfs.callbackhwnd = NULL;
SendMessage(winampParent,WM_WA_IPC,(WPARAM)&cfs,IPC_CONVERTFILE_END);
free(cfs.sourcefile);
free(cfs.destfile);
ZeroMemory(&cfs,sizeof(convertFileStruct));
}
bool TranscoderImp::TestTranscode(wchar_t * file, unsigned int destformat)
{
wchar_t tempfn[MAX_PATH], ext[5]=L".";
fourccToString(destformat,&ext[1]);
GetTempFilePath(ext,tempfn);
convertFileStructW cfs;
cfs.callbackhwnd = callbackhwnd;
cfs.sourcefile = file;
cfs.destfile = tempfn;
cfs.destformat[0] = destformat;
cfs.destformat[6] = mmioFOURCC('I','N','I',' ');
cfs.destformat[7] = (intptr_t)inifileA;
cfs.error = L"";
int v = SendMessage(winampParent,WM_WA_IPC,(WPARAM)&cfs,IPC_CONVERT_TEST);
_wunlink(tempfn);
return !!v;
}
bool TranscoderImp::FormatAcceptable(unsigned int format)
{
int l = outformats.size();
for(int i=0; i<l; i++)
{
if(fourccEqual(outformats[i], format))
return true;
}
return false;
}
bool TranscoderImp::FormatAcceptable(wchar_t * format)
{
return FormatAcceptable(stringToFourcc(format));
}
int TranscoderImp::GetOutputFormat(wchar_t * file, int *bitrate)
{
if (!FileExists(file))
return 0;
int fourcc = config->ReadInt(L"lastusedencoder",' A4M');
if (TestTranscode(file,fourcc))
{
char buf[100]="128";
convertConfigItem ccs={fourcc,"bitrate",buf,100, inifileA};
SendMessage(winampParent,WM_WA_IPC,(WPARAM)&ccs,IPC_CONVERT_CONFIG_GET_ITEM);
int br = atoi(buf)*1000;
if(bitrate) *bitrate = br;
return fourcc;
}
return 0;
}
bool TranscoderImp::ShouldTranscode(wchar_t * file)
{
if(TranscoderDisabled) return false;
wchar_t * ext = wcsrchr(file,L'.');
if(ext && FormatAcceptable(&ext[1])) {
if(transrate && getFileBitrate(file,winampParent) > 1000*transratethresh)
return true;
else if (translossless && isFileLossless(file))
return true;
else return false;
}
return true;
}
int TranscoderImp::CanTranscode(wchar_t * file, wchar_t * ext, int length)
{
if(TranscoderDisabled) return -1;
int bitrate;
unsigned int fmt = GetOutputFormat(file,&bitrate);
if(fmt) {
if(ext) {
ext[0]=L'.'; ext[1]=0;
char extA[8]=".";
convertConfigItem c = {fmt,"extension",&extA[1],6,AutoCharDup(config->GetIniFile())};
SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(WPARAM)&c,IPC_CONVERT_CONFIG_GET_ITEM);
if(extA[1]) wcsncpy(ext,AutoWide(extA), 10);
else fourccToString(fmt,&ext[1]);
free(c.configfile);
}
if (length <= 0)
length = getFileLength(file,winampParent);
return (bitrate/8) * length; // should transcode
}
return -1; // transcoding impossible
}
extern void filenameToItemRecord(wchar_t * file, itemRecordW * ice);
extern void copyTags(itemRecordW * in, wchar_t * out);
int TranscoderImp::TranscodeFile(wchar_t *inputFile, wchar_t *outputFile, int *killswitch, void (*callbackFunc)(void * callbackContext, wchar_t * status), void* callbackContext, wchar_t * caption)
{
if(caption) lstrcpyn(this->caption,caption,100);
this->callback = callbackFunc;
this->callbackContext = callbackContext;
convertDone = false;
int format = GetOutputFormat(inputFile);
if(!format) return -1;
if(!StartTranscode(format,inputFile,outputFile))
return -1;
while(!convertDone && !(*killswitch))
Sleep(50);
EndTranscode();
// copy the tags over
itemRecordW ice={0};
filenameToItemRecord(inputFile,&ice);
copyTags(&ice,outputFile);
freeRecord(&ice);
if(convertDone && callback)
callback(callbackContext,L"Done");
this->callback = NULL;
return convertDone?0:-1;
}
static void doConfigResizeChild(HWND parent, HWND child)
{
if (child)
{
RECT r;
GetWindowRect(GetDlgItem(parent, IDC_ENC_CONFIG), &r);
ScreenToClient(parent, (LPPOINT)&r);
SetWindowPos(child, 0, r.left, r.top, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
ShowWindow(child, SW_SHOWNA);
}
}
struct ConfigTranscoderParam
{
ConfigTranscoderParam()
{
winampParent=0;
configfile=0;
memset(&ccs, 0, sizeof(ccs));
config=0;
dev=0;
}
~ConfigTranscoderParam()
{
//list.deleteAll();
for (auto l : list)
{
delete l;
}
list.clear();
free((char*)ccs.extra_data[7]);
free(configfile);
}
HWND winampParent;
wchar_t *configfile;
FormatList list;
convertConfigStruct ccs;
C_Config * config;
Device *dev;
};
static INT_PTR CALLBACK config_dlgproc_transcode_advanced(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
{
static ConfigTranscoderParam *p;
switch(uMsg)
{
case WM_INITDIALOG:
p = (ConfigTranscoderParam *)lParam;
SetDlgItemText(hwndDlg,IDC_FORCE_BITRATE,p->config->ReadString(L"forcetranscodingbitrate",L"250"));
if(p->config->ReadInt(L"transrate",0)) CheckDlgButton(hwndDlg,IDC_CHECK_FORCE,BST_CHECKED);
if(p->config->ReadInt(L"translossless",0)) CheckDlgButton(hwndDlg,IDC_CHECK_FORCE_LOSSLESS,BST_CHECKED);
break;
case WM_COMMAND:
switch(LOWORD(wParam)) {
case IDOK:
{
wchar_t buf[10]=L"";
GetDlgItemText(hwndDlg,IDC_FORCE_BITRATE,buf,10);
p->config->WriteString(L"forcetranscodingbitrate",buf);
p->config->WriteInt(L"transrate",IsDlgButtonChecked(hwndDlg,IDC_CHECK_FORCE)?1:0);
p->config->WriteInt(L"translossless",IsDlgButtonChecked(hwndDlg,IDC_CHECK_FORCE_LOSSLESS)?1:0);
}
case IDCANCEL:
EndDialog(hwndDlg,0);
break;
}
break;
}
return 0;
}
BOOL TranscoderImp::transcodeconfig_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
{
static ConfigTranscoderParam *p;
switch(uMsg) {
case WM_INITDIALOG:
{
p = (ConfigTranscoderParam *)lParam;
if(p->config->ReadInt(L"enableTranscoder",1)) CheckDlgButton(hwndDlg,IDC_ENABLETRANSCODER,BST_CHECKED);
BuildEncodableFormatsList(p->list, p->winampParent, p->dev);
p->ccs.hwndParent = hwndDlg;
int encdef = p->config->ReadInt(L"lastusedencoder",0);
for(size_t i=0; i < p->list.size(); i++)
{
EncodableFormat * f = p->list[i];
int a = SendDlgItemMessage(hwndDlg, IDC_ENCFORMAT, CB_ADDSTRING, 0, (LPARAM)f->desc);
SendDlgItemMessage(hwndDlg, IDC_ENCFORMAT, CB_SETITEMDATA, (WPARAM)a, (LPARAM)f);
if(i==0 && encdef == 0) encdef = f->fourcc;
if(f->fourcc == encdef)
{
SendDlgItemMessage(hwndDlg, IDC_ENCFORMAT, CB_SETCURSEL, (WPARAM)a, 0);
p->ccs.format = f->fourcc;
}
}
p->ccs.hwndParent = hwndDlg;
HWND h = (HWND)SendMessage(p->winampParent, WM_WA_IPC, (WPARAM)&p->ccs, IPC_CONVERT_CONFIG);
doConfigResizeChild(hwndDlg, h);
}
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_ENABLETRANSCODER:
p->config->WriteInt(L"enableTranscoder",IsDlgButtonChecked(hwndDlg,IDC_ENABLETRANSCODER)?1:0);
break;
case IDC_ADVANCED:
return WASABI_API_DIALOGBOXPARAMW(IDD_CONFIG_TRANSCODING_ADVANCED,hwndDlg,config_dlgproc_transcode_advanced,(LPARAM)p);
case IDC_ENCFORMAT:
if (HIWORD(wParam) != CBN_SELCHANGE) return 0;
{
int sel = SendDlgItemMessage(hwndDlg, IDC_ENCFORMAT, CB_GETCURSEL, 0, 0);
if (sel != CB_ERR)
{
SendMessage(p->winampParent, WM_WA_IPC, (WPARAM)&p->ccs, IPC_CONVERT_CONFIG_END);
EncodableFormat * f = (EncodableFormat *)SendDlgItemMessage(hwndDlg, IDC_ENCFORMAT, CB_GETITEMDATA, sel, 0);
p->ccs.format = f->fourcc;
HWND h = (HWND)SendMessage(p->winampParent, WM_WA_IPC, (WPARAM)&p->ccs, IPC_CONVERT_CONFIG);
doConfigResizeChild(hwndDlg, h);
p->config->WriteInt(L"lastusedencoder",p->ccs.format);
}
}
break;
}
break;
case WM_DESTROY:
{
p->config->WriteInt(L"lastusedencoder",p->ccs.format);
SendMessage(p->winampParent, WM_WA_IPC, (WPARAM)&p->ccs, IPC_CONVERT_CONFIG_END);
delete p;
for( TranscoderImp *l_transcoder : transcoders )
l_transcoder->ReloadConfig();
}
break;
}
return 0;
}
void* TranscoderImp::ConfigureTranscoder(wchar_t * configProfile, HWND winampParent, C_Config * config, Device *dev)
{
ConfigTranscoderParam * p = new ConfigTranscoderParam;
p->config = config;
p->winampParent=winampParent;
p->configfile=_wcsdup(config->GetIniFile());
p->ccs.extra_data[6] = mmioFOURCC('I','N','I',' ');
p->ccs.extra_data[7] = (int)AutoCharDup(p->configfile);
p->dev = dev;
return p;
}
Reference in New Issue View Git Blame Copy Permalink