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

461 lines
13 KiB
C++
Raw Blame History

#include "XSPFLoader.h"
#include "../xml/obj_xml.h"
#include "../xml/ifc_xmlreadercallback.h"
#include "api__xspf.h"
#include "../winamp/wa_ipc.h"
#include <api/service/waservicefactory.h>
#include <shlwapi.h>
#include <strsafe.h>
// tries to retrieve the media library API (if it's not already retrieved
bool HasMediaLibraryAPI()
{
// TODO: should critical section this
if (!AGAVE_API_MLDB)
{
waServiceFactory *mldbFactory = WASABI_API_SVC->service_getServiceByGuid(mldbApiGuid);
if (mldbFactory)
AGAVE_API_MLDB = (api_mldb *)mldbFactory->getInterface(); // retrieve a pointer to the API object
}
return !!AGAVE_API_MLDB;
}
static bool HasTagzAPI()
{
// TODO: should critical section this
if (!AGAVE_API_TAGZ)
{
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(tagzGUID);
if (sf)
AGAVE_API_TAGZ = (api_tagz *)sf->getInterface(); // retrieve a pointer to the API object
}
return !!AGAVE_API_TAGZ;
}
const wchar_t* ATFString()
{
// TODO: should critical section this
if (!WASABI_API_APP)
{
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(applicationApiServiceGuid);
if (sf)
WASABI_API_APP = (api_application *)sf->getInterface(); // retrieve a pointer to the API object
}
if (WASABI_API_APP)
{
const wchar_t *atf = WASABI_API_APP->getATFString();
if (atf && *atf) return atf;
}
return L"%artist% - %title%";
}
// go check out XSPFLoader::Load before decyphering this class
class XSPFLoaderCallback : public ifc_xmlreadercallback
{
public:
XSPFLoaderCallback(ifc_playlistloadercallback *_playlist);
~XSPFLoaderCallback();
void xmlReaderOnStartElementCallback(const wchar_t *xmlpath, const wchar_t *xmltag, ifc_xmlreaderparams *params);
void xmlReaderOnEndElementCallback(const wchar_t *xmlpath, const wchar_t *xmltag);
void xmlReaderOnCharacterDataCallback(const wchar_t *xmlpath, const wchar_t *xmltag, const wchar_t *str);
protected:
RECVS_DISPATCH;
private:
enum
{
ELEMENT_NONE=-1,
ELEMENT_LOCATION=0,
ELEMENT_IDENTIFIER,
ELEMENT_TITLE,
ELEMENT_CREATOR,
ELEMENT_ALBUM,
ELEMENT_TRACKNUM,
NUM_ELEMENTS,
};
wchar_t *elements[NUM_ELEMENTS];
int element;
ifc_playlistloadercallback *playlist;
};
XSPFLoaderCallback::XSPFLoaderCallback(ifc_playlistloadercallback *_playlist)
{
element = ELEMENT_NONE;
for (int i=0;i<NUM_ELEMENTS;i++)
elements[i]=0;
playlist = _playlist;
}
XSPFLoaderCallback::~XSPFLoaderCallback()
{
for (int i=0;i<NUM_ELEMENTS;i++)
{
free(elements[i]);
elements[i]=0;
}
}
// this gets called for every opening tag
// xmlpath is the full XML path up to this point, delimited with \f (form feed)
// xmltag is the actual opening tag
// params is an object which lets you query for the attribtues in the tag
void XSPFLoaderCallback::xmlReaderOnStartElementCallback(const wchar_t *xmlpath, const wchar_t *xmltag, ifc_xmlreaderparams *params)
{
if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\flocation"))
element=ELEMENT_LOCATION;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\fidentifier"))
element=ELEMENT_IDENTIFIER;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\ftitle"))
element=ELEMENT_TITLE;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\fcreator"))
element=ELEMENT_CREATOR;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\falbum"))
element=ELEMENT_ALBUM;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\ftracknum"))
element=ELEMENT_TRACKNUM;
else
element=ELEMENT_NONE;
}
static void QueryStringAdd(const wchar_t *value, wchar_t *&query, size_t &query_len)
{
if (!value || !*value) return;
while (value && *value && query_len > 3) {
if (*value == L'%') { *query++ = L'%'; *query++ = L'%'; query_len-=2;}
else if (*value == L'\"') { *query++ = L'%'; *query++ = L'2'; *query++ = L'2'; query_len-=3;}
else if (*value == L'\'') { *query++ = L'%'; *query++ = L'2'; *query++ = L'7'; query_len-=3;}
else if (*value == L'[') { *query++ = L'%'; *query++ = L'5'; *query++ = L'B'; query_len-=3;}
else if (*value == L']') { *query++ = L'%'; *query++ = L'5'; *query++ = L'D'; query_len-=3;}
else if (*value == L'(') { *query++ = L'%'; *query++ = L'2'; *query++ = L'8'; query_len-=3;}
else if (*value == L')') { *query++ = L'%'; *query++ = L'2'; *query++ = L'9'; query_len-=3;}
else if (*value == L'#') { *query++ = L'%'; *query++ = L'2'; *query++ = L'3'; query_len-=3;}
else { *query++ = *value; query_len--; }
value++;
}
*query = 0;
}
class ItemRecordTagProvider : public ifc_tagprovider
{
public:
ItemRecordTagProvider(itemRecordW *item) : t(item) {}
wchar_t *GetTag(const wchar_t *name, ifc_tagparams *parameters);
void FreeTag(wchar_t *Tag);
protected:
RECVS_DISPATCH;
private:
itemRecordW *t;
};
#define CBCLASS ItemRecordTagProvider
START_DISPATCH;
CB(IFC_TAGPROVIDER_GET_TAG, GetTag);
VCB(IFC_TAGPROVIDER_FREE_TAG, FreeTag);
END_DISPATCH;
#undef CBCLASS
wchar_t *ItemRecordTagProvider::GetTag(const wchar_t *tag, ifc_tagparams *parameters)
{
bool copy=false;
wchar_t buf[128]={0};
wchar_t *value = NULL;
if (!_wcsicmp(tag, L"artist")) value = t->artist;
else if (!_wcsicmp(tag, L"album")) value = t->album;
else if (!_wcsicmp(tag, L"filename")) value = t->filename;
else if (!_wcsicmp(tag, L"title")) value = t->title;
else if (!_wcsicmp(tag, L"year"))
{
if (t->year > 0)
{
StringCchPrintfW(buf, 128, L"%04d", t->year);
value = buf;
}
}
else if (!_wcsicmp(tag, L"genre")) value = t->genre;
else if (!_wcsicmp(tag, L"comment")) value = t->comment;
else if (!_wcsicmp(tag, L"tracknumber") || !_wcsicmp(tag, L"track"))
{
if (t->track > 0)
{
if (t->tracks > 0)
StringCchPrintfW(buf, 128, L"%02d/%02d", t->track, t->tracks);
else
StringCchPrintfW(buf, 128, L"%02d", t->track);
value = buf;
}
}
else if (!_wcsicmp(tag, L"disc"))
{
if (t->disc > 0)
{
if (t->discs > 0)
StringCchPrintfW(buf, 128, L"%d/%d", t->disc, t->discs);
else
StringCchPrintfW(buf, 128, L"%d", t->disc);
value = buf;
}
}
else if (!_wcsicmp(tag, L"rating"))
{
if (t->rating > 0)
{
StringCchPrintfW(buf, 128, L"%d", t->rating);
value = buf;
}
}
else if (!_wcsicmp(tag, L"playcount"))
{
if (t->playcount > 0)
{
StringCchPrintfW(buf, 128, L"%d", t->playcount);
value = buf;
}
}
else if (!_wcsicmp(tag, L"bitrate"))
{
if (t->bitrate > 0)
{
StringCchPrintfW(buf, 128, L"%d", t->bitrate);
value = buf;
}
}
else if (!_wcsicmp(tag, L"bpm"))
{
if (t->bpm > 0)
{
StringCchPrintfW(buf, 128, L"%d", t->bpm);
value = buf;
}
}
else if (!_wcsicmp(tag, L"albumartist")) value = t->albumartist;
else if (!_wcsicmp(tag, L"publisher")) value = t->publisher;
else if (!_wcsicmp(tag, L"composer")) value = t->composer;
else if (!_wcsicmp(tag, L"replaygain_album_gain")) value = t->replaygain_album_gain;
else if (!_wcsicmp(tag, L"replaygain_track_gain")) value = t->replaygain_track_gain;
else if (!_wcsicmp(tag, L"GracenoteFileID"))
{
copy=true;
value = getRecordExtendedItem(t, L"GracenoteFileID");
}
else if (!_wcsicmp(tag, L"GracenoteExtData"))
{
copy=true;
value = getRecordExtendedItem(t, L"GracenoteExtData");
}
else
return 0;
if (!value)
return 0;
else
{
if (copy || value == buf)
return AGAVE_API_MLDB->DuplicateString(value);
else
{
AGAVE_API_MLDB->RetainString(value);
return value;
}
}
}
void ItemRecordTagProvider::FreeTag(wchar_t *tag)
{
AGAVE_API_MLDB->ReleaseString(tag);
}
// this gets called for every closing tag
void XSPFLoaderCallback::xmlReaderOnEndElementCallback(const wchar_t *xmlpath, const wchar_t *xmltag)
{
if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack"))
{
// end of track info
if (elements[ELEMENT_LOCATION] // if we have a location
&& (PathIsURL(elements[ELEMENT_LOCATION]) // and it's a URL
|| GetFileAttributes(elements[ELEMENT_LOCATION]) != INVALID_FILE_ATTRIBUTES)) // or a file that exists
{
// location field seemed OK so go ahead and add
// TODO try using the length if available...
playlist->OnFile(elements[ELEMENT_LOCATION], 0, -1, 0);
}
else if (HasMediaLibraryAPI()) // we don't have a good location so let's hit the media library
{
// let's build a query out of what we have
bool needs_and=false;
wchar_t query[2048]={0};
wchar_t *query_end=query;
size_t query_size=2048;
struct {
const wchar_t *field_name;
int field_value;
} fields[] =
{
{L"artist", ELEMENT_CREATOR},
{L"title", ELEMENT_TITLE},
};
for(size_t i=0;i!=sizeof(fields)/sizeof(fields[0]);i++)
{
if (elements[fields[i].field_value])
{
if (needs_and)
StringCchCopyEx(query_end, query_size, L" AND ", &query_end, &query_size, 0);
StringCchPrintfEx(query_end, query_size, &query_end, &query_size, 0, L"(%s == \"", fields[i].field_name);
QueryStringAdd(elements[fields[i].field_value], query_end, query_size);
StringCchCopyEx(query_end, query_size, L"\")", &query_end, &query_size, 0);
needs_and=true;
}
}
if (query[0])
{
itemRecordListW *results = AGAVE_API_MLDB->QueryLimit(query, 1);
if (results && results->Size >= 1 && results->Items[0].filename)
{
if (HasTagzAPI())
{
wchar_t title[2048]={0};
ItemRecordTagProvider provider(&results->Items[0]);
AGAVE_API_TAGZ->format(ATFString(), title, 2048, &provider, 0);
int length = -1;
if (results->Items[0].length > 0)
length=results->Items[0].length*1000;
playlist->OnFile(results->Items[0].filename, title, length, 0);
}
else
{
int length = -1;
if (results->Items[0].length > 0)
length=results->Items[0].length*1000;
playlist->OnFile(results->Items[0].filename, 0, length, 0);
}
}
AGAVE_API_MLDB->FreeRecordList(results);
}
}
for (int i=0;i<NUM_ELEMENTS;i++)
{
free(elements[i]);
elements[i]=0;
}
}
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\flocation"))
element=ELEMENT_NONE;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\fidentifier"))
element=ELEMENT_NONE;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\ftitle"))
element=ELEMENT_NONE;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\fcreator"))
element=ELEMENT_NONE;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\falbum"))
element=ELEMENT_NONE;
else if (!wcscmp(xmlpath, L"playlist\ftrackList\ftrack\ftracknum"))
element=ELEMENT_NONE;
}
void XSPFLoaderCallback::xmlReaderOnCharacterDataCallback(const wchar_t *xmlpath, const wchar_t *xmltag, const wchar_t *str)
{
if (element!=ELEMENT_NONE)
{
// this certainly isn't the most memory efficient way to do this but it'll work for now :)
if (elements[element] == 0)
{
elements[element] = wcsdup(str);
}
else
{
size_t elementlen = wcslen(elements[element]);
size_t incominglen = wcslen(str);
wchar_t *&newstr = elements[element], *oldstr = newstr;
newstr = (wchar_t *)realloc(newstr, sizeof(wchar_t)*(elementlen+incominglen+1));
if (newstr != NULL)
{
memcpy(newstr+elementlen, str, incominglen*sizeof(wchar_t));
newstr[elementlen+incominglen] = 0;
}
}
}
}
#define CBCLASS XSPFLoaderCallback
START_DISPATCH;
VCB(ONSTARTELEMENT, xmlReaderOnStartElementCallback)
VCB(ONENDELEMENT, xmlReaderOnEndElementCallback)
VCB(ONCHARDATA, xmlReaderOnCharacterDataCallback)
END_DISPATCH;
#undef CBCLASS
/* ---------------------------- */
static int LoadFile(obj_xml *parser, const wchar_t *filename)
{
HANDLE file = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
if (file == INVALID_HANDLE_VALUE)
return IFC_PLAYLISTLOADER_FAILED;
while (true)
{
char data[1024] = {0};
DWORD bytesRead = 0;
if (ReadFile(file, data, 1024, &bytesRead, NULL) && bytesRead)
{
if (parser->xmlreader_feed(data, bytesRead) != API_XML_SUCCESS)
{
CloseHandle(file);
return IFC_PLAYLISTLOADER_FAILED;
}
}
else
break;
}
CloseHandle(file);
if (parser->xmlreader_feed(0, 0) != API_XML_SUCCESS)
return IFC_PLAYLISTLOADER_FAILED;
return IFC_PLAYLISTLOADER_SUCCESS;
}
// this get called by Winamp
// you a method in the passed playlist loader callback object
// for each item in the playlist
int XSPFLoader::Load(const wchar_t *filename, ifc_playlistloadercallback *playlist)
{
// first thing we'll need is an XML parser
// we'll have to do the wasabi dance to get it
// first, get the service factory for creating XML objects
waServiceFactory *xmlFactory = WASABI_API_SVC->service_getServiceByGuid(obj_xmlGUID);
if (xmlFactory)
{
obj_xml *parser = (obj_xml *)xmlFactory->getInterface(); // create an XML parser
if (parser)
{
// ok now we can get down to biz'nes
XSPFLoaderCallback xmlCallback(playlist);
parser->xmlreader_registerCallback(L"*", &xmlCallback);
parser->xmlreader_setCaseSensitive();
parser->xmlreader_open();
int ret = LoadFile(parser, filename);
parser->xmlreader_unregisterCallback(&xmlCallback);
parser->xmlreader_close();
xmlFactory->releaseInterface(parser); // destroy the XML parser via the service factory
return ret;
}
}
return IFC_PLAYLISTLOADER_FAILED;
}
// Define the dispatch table
#define CBCLASS XSPFLoader
START_DISPATCH;
CB(IFC_PLAYLISTLOADER_LOAD, Load)
END_DISPATCH;
#undef CBCLASS
Reference in New Issue View Git Blame Copy Permalink