mirrors/winamp
Archived
1
0
Fork 0
Code
This repository has been archived on 2024-10-17. You can view files and clone it, but cannot push or open issues or pull requests.
community
winamp/Src/Plugins/General/gen_ml/ml_lib.cpp
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

586 lines
14 KiB
C++
Raw Permalink Blame History

/*
** Copyright © 2003-2014 Winamp SA
**
** This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held
** liable for any damages arising from the use of this software.
**
** Permission is granted to anyone to use this software for any purpose, including commercial applications, and to
** alter it and redistribute it freely, subject to the following restrictions:
**
** 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software.
** If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
**
** 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
**
** 3. This notice may not be removed or altered from any source distribution.
**
*/
#include <windows.h>
#include "ml.h"
void freeRecord(itemRecord *p)
{
if (p)
{
free(p->title);
free( p->artist );
free( p->ext );
free(p->comment);
free(p->album);
free(p->genre);
free(p->filename);
if (p->extended_info)
{
for (int x = 0; p->extended_info[x]; x ++)
free(p->extended_info[x]);
free(p->extended_info);
p->extended_info = 0;
}
}
}
void freeRecordList(itemRecordList *obj)
{
if (obj)
{
emptyRecordList(obj);
free(obj->Items);
obj->Items=0;
obj->Alloc=obj->Size=0;
}
}
void emptyRecordList(itemRecordList *obj)
{
if (obj)
{
itemRecord *p=obj->Items;
while (obj->Size-->0)
{
freeRecord(p);
p++;
}
obj->Size=0;
}
}
void allocRecordList(itemRecordList *obj, int newsize, int granularity)
{
if (newsize < obj->Alloc || newsize < obj->Size) return;
int old_Alloc = obj->Alloc;
obj->Alloc=newsize+granularity;
itemRecord *data = (itemRecord*)realloc(obj->Items, sizeof(itemRecord) * obj->Alloc);
if (!data)
{
data = (itemRecord*)malloc(sizeof(itemRecord) * obj->Alloc);
if (data)
{
memcpy(data, obj->Items, sizeof(itemRecord) * old_Alloc);
free(obj->Items);
obj->Items = data;
}
else
obj->Alloc = old_Alloc;
}
else
obj->Items = data;
if (!old_Alloc) memset(data, 0, sizeof(itemRecordW) * obj->Alloc);
if (!obj->Items) obj->Alloc = 0;
}
void compactRecordList(itemRecordListW *obj)
{
if (obj->Size && obj->Size < obj->Alloc - 1024)
{
size_t old_Alloc = obj->Size;
obj->Alloc = obj->Size;
itemRecordW *data = (itemRecordW *)realloc(obj->Items, sizeof(itemRecordW) * obj->Alloc);
if (!data)
{
data = (itemRecordW *)malloc(sizeof(itemRecordW) * obj->Alloc);
if (data)
{
memcpy(data, obj->Items, sizeof(itemRecordW) * old_Alloc);
free(obj->Items);
obj->Items = data;
}
else
obj->Alloc = (int)old_Alloc;
}
else
obj->Items = data;
}
}
void copyRecord(itemRecord *out, const itemRecord *in)
{
#define COPYSTR(FOO) out->FOO = in->FOO ? _strdup(in->FOO) : 0;
COPYSTR(filename)
COPYSTR( title )
COPYSTR( ext )
COPYSTR(album)
COPYSTR(artist)
COPYSTR(comment)
COPYSTR(genre)
out->year=in->year;
out->track=in->track;
out->length=in->length;
#undef COPYSTR
out->extended_info=0;
if (in->extended_info)
{
for (int y = 0; in->extended_info[y]; y ++)
{
char *p=in->extended_info[y];
if (*p) setRecordExtendedItem(out,p,p+strlen(p)+1);
}
}
}
void copyRecordList(itemRecordList *out, const itemRecordList *in)
{
allocRecordList(out,out->Size+in->Size,0);
if (!out->Items) return;
for (int x = 0; x < in->Size; x ++)
{
copyRecord(&out->Items[out->Size++],&in->Items[x]);
}
}
char *getRecordExtendedItem(const itemRecord *item, const char *name)
{
if (item->extended_info)
{
for (int x = 0; item->extended_info[x]; x ++)
{
if (!_stricmp(item->extended_info[x],name))
return item->extended_info[x]+strlen(name)+1;
}
}
return NULL;
}
void setRecordExtendedItem(itemRecord *item, const char *name, char *value)
{
int x=0;
if (item->extended_info)
{
for (x = 0; item->extended_info[x]; x ++)
{
if (!_stricmp(item->extended_info[x],name))
{
size_t name_len = strlen(name), value_len = strlen(value);
if (value_len>strlen(item->extended_info[x]+name_len+1))
{
free(item->extended_info[x]);
item->extended_info[x]=(char*)malloc(name_len+value_len+2);
}
strncpy(item->extended_info[x], name, name_len);
strncpy(item->extended_info[x]+strlen(name)+1, value, value_len);
return;
}
}
}
// x=number of valid items.
char **data = (char**)realloc(item->extended_info,sizeof(char*) * (x+2));
if (data)
{
// if we could allocate then add, otherwise we'll have to skip
item->extended_info = data;
size_t name_len = strlen(name), value_len = strlen(value);
item->extended_info[x]=(char*)malloc(name_len+value_len+2);
strncpy(item->extended_info[x], name, name_len);
strncpy(item->extended_info[x]+name_len+1, value, value_len);
item->extended_info[x+1]=0;
}
else
{
data=(char**)_aligned_malloc(sizeof(char*) * (x+2), 16);
if (data)
{
memcpy(data, item->extended_info, sizeof(char*) * x);
free(item->extended_info);
// if we could allocate then add, otherwise we'll have to skip
item->extended_info = data;
size_t name_len = strlen(name), value_len = strlen(value);
item->extended_info[x]=(char*)malloc(name_len+value_len+2);
strncpy(item->extended_info[x], name, name_len);
strncpy(item->extended_info[x]+name_len+1, value, value_len);
item->extended_info[x+1]=0;
}
}
}
/*
----------------------------------
wide version starts here
----------------------------------
*/
void freeRecord(itemRecordW *p)
{
if (p)
{
free(p->title);
free(p->artist);
free(p->comment);
free(p->album);
free(p->genre);
free(p->filename);
free(p->albumartist);
free(p->replaygain_album_gain);
free(p->replaygain_track_gain);
free(p->publisher);
free(p->composer);
if (p->extended_info)
{
for (int x = 0; p->extended_info[x].key; x ++)
{
free(p->extended_info[x].key);
free(p->extended_info[x].value);
}
free(p->extended_info);
p->extended_info = 0;
}
}
}
void freeRecordList(itemRecordListW *obj)
{
if (obj)
{
emptyRecordList(obj);
free(obj->Items);
obj->Items=0;
obj->Alloc=obj->Size=0;
}
}
void emptyRecordList(itemRecordListW *obj)
{
if (obj)
{
itemRecordW *p=obj->Items;
while (obj->Size-->0)
{
freeRecord(p);
p++;
}
obj->Size=0;
}
}
void allocRecordList(itemRecordListW *obj, int newsize, int granularity)
{
if (newsize < obj->Alloc || newsize < obj->Size) return;
int old_Alloc = obj->Alloc;
obj->Alloc=newsize+granularity;
itemRecordW *data = (itemRecordW*)realloc(obj->Items,sizeof(itemRecordW)*obj->Alloc);
if (!data)
{
data = (itemRecordW*)malloc(sizeof(itemRecordW) * obj->Alloc);
if (data)
{
memcpy(data, obj->Items, sizeof(itemRecordW) * obj->Alloc);
free(obj->Items);
obj->Items = data;
}
else
obj->Alloc = old_Alloc;
}
else
obj->Items = data;
if (!old_Alloc) memset(data, 0, sizeof(itemRecordW) * obj->Alloc);
if (!obj->Items) obj->Alloc = 0;
}
void copyRecord(itemRecordW *out, const itemRecordW *in)
{
#define COPYSTR(FOO) out->FOO = in->FOO ? _wcsdup(in->FOO) : 0;
#define COPY(FOO) out->FOO = in->FOO;
COPYSTR(filename);
COPYSTR(title);
COPYSTR(album);
COPYSTR(artist);
COPYSTR(comment);
COPYSTR(genre);
COPYSTR(albumartist);
COPYSTR(replaygain_album_gain);
COPYSTR(replaygain_track_gain);
COPYSTR(publisher);
COPYSTR(composer);
COPY(year);
COPY(track);
COPY(tracks);
COPY(length);
COPY(rating);
COPY(playcount);
COPY(lastplay);
COPY(lastupd);
COPY(filetime);
COPY(filesize);
COPY(bitrate);
COPY(type);
COPY(disc);
COPY(discs);
COPY(bpm);
COPYSTR(category);
#undef COPYSTR
out->extended_info=0;
if (in->extended_info)
{
for (int y = 0; in->extended_info[y].key; y ++)
{
setRecordExtendedItem(out,in->extended_info[y].key,in->extended_info[y].value);
}
}
}
void copyRecordList(itemRecordListW *out, const itemRecordListW *in)
{
allocRecordList(out,out->Size+in->Size,0);
if (!out->Items) return;
for (int x = 0; x < in->Size; x ++)
{
copyRecord(&out->Items[out->Size++],&in->Items[x]);
}
}
wchar_t *getRecordExtendedItem(const itemRecordW *item, const wchar_t *name)
{
if (item->extended_info)
{
for (size_t x = 0; item->extended_info[x].key; x ++)
{
if (!_wcsicmp(item->extended_info[x].key,name))
return item->extended_info[x].value;
}
}
return NULL;
}
wchar_t *getRecordExtendedItem_fast(const itemRecordW *item, const wchar_t *name)
{
if (item->extended_info)
{
for (size_t x = 0; item->extended_info[x].key; x ++)
{
if (item->extended_info[x].key == name)
return item->extended_info[x].value;
}
}
return NULL;
}
void setRecordExtendedItem(itemRecordW *item, const wchar_t *name, const wchar_t *value)
{
size_t x=0;
if (item->extended_info) for (x = 0; item->extended_info[x].key; x ++)
{
if (!_wcsicmp(item->extended_info[x].key,name))
{
free(item->extended_info[x].value);
item->extended_info[x].value = _wcsdup(value);
return;
}
}
// x=number of valid items.
extendedInfoW *data = (extendedInfoW *)realloc(item->extended_info, sizeof(extendedInfoW) * (x+2));
if (data)
{
item->extended_info = data;
item->extended_info[x].key = _wcsdup(name);
item->extended_info[x].value = _wcsdup(value);
item->extended_info[x+1].key=0;
item->extended_info[x+1].value=0;
}
else
{
data=(extendedInfoW *)_aligned_malloc(sizeof(extendedInfoW) * (x+2), 16);
if (data)
{
item->extended_info=data;
item->extended_info[x].key = _wcsdup(name);
item->extended_info[x].value = _wcsdup(value);
item->extended_info[x+1].key=0;
item->extended_info[x+1].value=0;
}
}
}
// this version assumes that the 'name' won't already be in the itemRecord
void setRecordExtendedItem_fast(itemRecordW *item, const wchar_t *name, const wchar_t *value)
{
int x=0;
if (item->extended_info)
{
for (x = 0; item->extended_info[x].key; x ++)
{
}
}
// x=number of valid items.
extendedInfoW *data=(extendedInfoW *)_aligned_realloc(item->extended_info,sizeof(extendedInfoW) * (x+2), 16);
if (data)
{
item->extended_info=data;
item->extended_info[x].key = _wcsdup(name);
item->extended_info[x].value = _wcsdup(value);
item->extended_info[x+1].key=0;
item->extended_info[x+1].value=0;
}
else
{
data=(extendedInfoW *)_aligned_malloc(sizeof(extendedInfoW) * (x+2), 16);
if (data)
{
item->extended_info=data;
item->extended_info[x].key = _wcsdup(name);
item->extended_info[x].value = _wcsdup(value);
item->extended_info[x+1].key=0;
item->extended_info[x+1].value=0;
}
}
}
// TODO: redo this without AutoChar
#include "../nu/AutoChar.h"
#define COPY_EXTENDED_STR(field) if (input-> ## field && input-> ## field ## [0]) setRecordExtendedItem(output, #field, AutoChar(input-> ## field));
#define COPY_EXTENDED_INT(field) if (input->##field > 0) { char temp[64] = {0}; _itoa(input->##field, temp, 10); setRecordExtendedItem(output, #field, temp); }
#define COPY_EXTENDED_INT64(field) if (input->##field > 0) { char temp[64] = {0}; _i64toa(input->##field, temp, 10); setRecordExtendedItem(output, #field, temp); }
#define COPY_EXTENDED_INT0(field) if (input->##field >= 0) { char temp[64] = {0}; _itoa(input->##field, temp, 10); setRecordExtendedItem(output, #field, temp); }
void convertRecord(itemRecord *output, const itemRecordW *input)
{
output->filename=AutoCharDup(input->filename);
output->title = AutoCharDup( input->title );
output->ext = AutoCharDup( input->ext );
output->album=AutoCharDup(input->album);
output->artist=AutoCharDup(input->artist);
output->comment=AutoCharDup(input->comment);
output->genre=AutoCharDup(input->genre);
output->year=input->year;
output->track=input->track;
output->length=input->length;
output->extended_info=0;
COPY_EXTENDED_STR(albumartist);
COPY_EXTENDED_STR(replaygain_album_gain);
COPY_EXTENDED_STR(replaygain_track_gain);
COPY_EXTENDED_STR(publisher);
COPY_EXTENDED_STR(composer);
COPY_EXTENDED_INT(tracks);
COPY_EXTENDED_INT(rating);
COPY_EXTENDED_INT(playcount);
COPY_EXTENDED_INT64(lastplay);
COPY_EXTENDED_INT64(lastupd);
COPY_EXTENDED_INT64(filetime);
COPY_EXTENDED_INT(filesize);
COPY_EXTENDED_INT(bitrate);
COPY_EXTENDED_INT0(type);
COPY_EXTENDED_INT(disc);
COPY_EXTENDED_INT(discs);
COPY_EXTENDED_INT(bpm);
COPY_EXTENDED_STR(category);
if (input->extended_info)
{
for (int y = 0; input->extended_info[y].key; y ++)
{
setRecordExtendedItem(output, AutoChar(input->extended_info[y].key), AutoChar(input->extended_info[y].value));
}
}
}
#undef COPY_EXTENDED_STR
#undef COPY_EXTENDED_INT
#undef COPY_EXTENDED_INT0
#include "../nu/AutoWide.h"
#define COPY_EXTENDED_STR(field) output->##field = AutoWideDup(getRecordExtendedItem(input, #field));
#define COPY_EXTENDED_INT(field) { char *x = getRecordExtendedItem(input, #field); output->##field=x?atoi(x):-1; }
void convertRecord(itemRecordW *output, const itemRecord *input)
{
output->filename=AutoWideDup(input->filename);
output->title=AutoWideDup(input->title);
output->ext = AutoWideDup( input->ext );
output->album=AutoWideDup(input->album);
output->artist=AutoWideDup(input->artist);
output->comment=AutoWideDup(input->comment);
output->genre=AutoWideDup(input->genre);
output->year=input->year;
output->track=input->track;
output->length=input->length;
output->extended_info=0;
COPY_EXTENDED_STR(albumartist);
COPY_EXTENDED_STR(replaygain_album_gain);
COPY_EXTENDED_STR(replaygain_track_gain);
COPY_EXTENDED_STR(publisher);
COPY_EXTENDED_STR(composer);
COPY_EXTENDED_INT(tracks);
COPY_EXTENDED_INT(rating);
COPY_EXTENDED_INT(playcount);
COPY_EXTENDED_INT(lastplay);
COPY_EXTENDED_INT(lastupd);
COPY_EXTENDED_INT(filetime);
COPY_EXTENDED_INT(filesize);
COPY_EXTENDED_INT(type);
COPY_EXTENDED_INT(disc);
COPY_EXTENDED_INT(discs);
COPY_EXTENDED_INT(bpm);
COPY_EXTENDED_INT(bitrate);
COPY_EXTENDED_STR(composer);
COPY_EXTENDED_STR(category);
// TODO: copy input's extended fields
}
#undef COPY_EXTENDED_STR
#undef COPY_EXTENDED_INT
void convertRecordList(itemRecordList *output, const itemRecordListW *input)
{
output->Alloc = output->Size = input->Size;
output->Items = (itemRecord*)calloc(sizeof(itemRecord),input->Size);
if (output->Items)
{
for(int i=0; i < input->Size; i++)
{
convertRecord(&output->Items[i],&input->Items[i]);
}
}
else
output->Alloc = output->Size = 0;
}
void convertRecordList(itemRecordListW *output, const itemRecordList *input)
{
output->Alloc = output->Size = input->Size;
output->Items = (itemRecordW*)calloc(sizeof(itemRecordW),input->Size);
if (output->Items)
{
for(int i=0; i < input->Size; i++)
{
convertRecord(&output->Items[i],&input->Items[i]);
}
}
}
View Git Blame Copy Permalink