Initial community commit
This commit is contained in:
parent
537bcbc862
commit
fc06254474
16440 changed files with 4239995 additions and 2 deletions
432
Src/Plugins/Library/ml_pmp/autofill.cpp
Normal file
432
Src/Plugins/Library/ml_pmp/autofill.cpp
Normal file
|
@ -0,0 +1,432 @@
|
|||
/*
|
||||
** This is adapted from the autofill code in ml_ipod. It was originally written by and is
|
||||
** Copyright (C) Will Fisher and Justin Frankel. It remains under the following licence:
|
||||
**
|
||||
** 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 <time.h>
|
||||
#include "../../General/gen_ml/ml.h"
|
||||
#include "pmp.h"
|
||||
#include "../../General/gen_ml/itemlist.h"
|
||||
#include "DeviceView.h"
|
||||
#include "mt19937ar.h"
|
||||
#include "config.h"
|
||||
#include "../nu/AutoChar.h"
|
||||
#include "metadata_utils.h"
|
||||
#include "api__ml_pmp.h"
|
||||
|
||||
extern winampMediaLibraryPlugin plugin;
|
||||
|
||||
extern C_ItemList * getSelectedItems(bool all=false);
|
||||
|
||||
typedef struct {
|
||||
wchar_t * albumName;
|
||||
int rating;
|
||||
float ratingf;
|
||||
int lastplayed;
|
||||
int size;
|
||||
bool album;
|
||||
itemRecordW * ice;
|
||||
} AutoFillItem;
|
||||
|
||||
static void randomizeList(void *list, int elems, int elemsize) {
|
||||
if (elems < 2) return;
|
||||
if (elemsize < 1) return;
|
||||
char *plist=(char*)list;
|
||||
int p;
|
||||
char *tmp=(char*)calloc(elemsize, sizeof(char));
|
||||
if (!tmp) return;
|
||||
for (p = 0; p < elems; p ++) {
|
||||
int np=genrand_int31()%elems;
|
||||
if (p != np) {
|
||||
np*=elemsize;
|
||||
int pp=p*elemsize;
|
||||
memcpy(tmp,plist+pp,elemsize);
|
||||
memcpy(plist+pp,plist+np,elemsize);
|
||||
memcpy(plist+np,tmp,elemsize);
|
||||
}
|
||||
}
|
||||
free(tmp);
|
||||
}
|
||||
|
||||
#define atoi_NULLOK(s) ((s)?atoi(s):0)
|
||||
#define STRCMP_NULLOK(a,b) _wcsicmp(a?a:L"",b?b:L"")
|
||||
|
||||
static int sortFunc_icealbums(const void *elem1, const void *elem2) {
|
||||
itemRecordW * a = (itemRecordW *)elem1;
|
||||
itemRecordW * b = (itemRecordW *)elem2;
|
||||
return STRCMP_NULLOK(a->album,b->album);
|
||||
}
|
||||
|
||||
|
||||
static void autoFill_songfilter(Device * dev, C_ItemList * list, itemRecordListW * results) {
|
||||
if (results) {
|
||||
for(int i=0; i < results->Size; i++) {
|
||||
AutoFillItem * a = (AutoFillItem *)calloc(sizeof(AutoFillItem),1);
|
||||
a->rating = results->Items[i].rating;
|
||||
a->lastplayed = (int)results->Items[i].lastplay;
|
||||
a->size = (int)dev->getTrackSizeOnDevice(&results->Items[i]);
|
||||
a->album = false;
|
||||
a->ice = &results->Items[i];
|
||||
a->albumName=L"arse";
|
||||
list->Add(a);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void autoFill_songfilter(Device * dev, C_ItemList * list, C_ItemList * results) {
|
||||
for(int i=0; i < results->GetSize(); i++) {
|
||||
itemRecordW *r = (itemRecordW*)results->Get(i);
|
||||
AutoFillItem * a = (AutoFillItem *)calloc(sizeof(AutoFillItem),1);
|
||||
a->rating = r->rating;
|
||||
a->lastplayed = (int)r->lastplay;
|
||||
a->size = (int)dev->getTrackSizeOnDevice(r);
|
||||
a->album = false;
|
||||
a->ice = r;
|
||||
a->albumName=L"arse";
|
||||
list->Add(a);
|
||||
}
|
||||
}
|
||||
|
||||
static void autoFill_albumfilter(Device * dev, C_ItemList * list, itemRecordListW * results, C_ItemList * res = NULL) {
|
||||
if (results)
|
||||
qsort(results->Items,results->Size,sizeof(itemRecordW),sortFunc_icealbums);
|
||||
AutoFillItem * curalbum = NULL;
|
||||
wchar_t * albumName=NULL;
|
||||
int albumSize=0;
|
||||
__int64 lastplayacc=0;
|
||||
int size = res?res->GetSize():(results?results->Size:0);
|
||||
int i;
|
||||
for(i=0; i < size; i++) {
|
||||
itemRecordW * item = res?(itemRecordW*)res->Get(i):&results->Items[i];
|
||||
if(!curalbum || STRCMP_NULLOK(item->album,albumName) != 0) {
|
||||
if(curalbum && albumSize) {
|
||||
curalbum->lastplayed = (int)(lastplayacc / (__int64)albumSize);
|
||||
curalbum->ratingf /= (float)albumSize;
|
||||
list->Add(curalbum);
|
||||
}
|
||||
AutoFillItem * a = (AutoFillItem *)calloc(sizeof(AutoFillItem),1);
|
||||
a->ratingf = (float)item->rating;
|
||||
lastplayacc = item->lastplay;
|
||||
a->size = (int)dev->getTrackSizeOnDevice(item);
|
||||
a->album = true;
|
||||
a->albumName = item->album;
|
||||
curalbum = a;
|
||||
albumName = a->albumName;
|
||||
albumSize++;
|
||||
} else {
|
||||
albumSize++;
|
||||
curalbum->size += (int)dev->getTrackSizeOnDevice(item);
|
||||
curalbum->ratingf += (float)item->rating;
|
||||
lastplayacc += item->lastplay;
|
||||
}
|
||||
}
|
||||
if(curalbum && albumSize) {
|
||||
curalbum->lastplayed = (int)(lastplayacc / (__int64)albumSize);
|
||||
curalbum->ratingf /= (float)albumSize;
|
||||
list->Add(curalbum);
|
||||
}
|
||||
|
||||
//FUCKO: think of something clever to make the ratings relevant
|
||||
for(i=0; i < list->GetSize(); i++) {
|
||||
AutoFillItem * a = (AutoFillItem *)list->Get(i);
|
||||
a->rating = (int)(a->ratingf + 0.5);
|
||||
if(a->rating > 5) a->rating = 5;
|
||||
}
|
||||
}
|
||||
|
||||
// FUCKO lame O(n^2) gayness. Make this better.
|
||||
static void autoFill_addAlbums(C_ItemList * albums, itemRecordListW * songs, C_ItemList * dest) {
|
||||
if (songs) {
|
||||
for(int i=0; i < songs->Size; i++)
|
||||
for(int j=0; j < albums->GetSize(); j++)
|
||||
if(STRCMP_NULLOK(songs->Items[i].album,(wchar_t *)albums->Get(j))==0)
|
||||
dest->Add(&songs->Items[i]);
|
||||
}
|
||||
}
|
||||
|
||||
static int sortFunc_autofill(const void *elem1, const void *elem2)
|
||||
{
|
||||
AutoFillItem *a=(AutoFillItem *)*(void **)elem1;
|
||||
AutoFillItem *b=(AutoFillItem *)*(void **)elem2;
|
||||
return a->lastplayed - b->lastplayed;
|
||||
}
|
||||
|
||||
itemRecordListW * generateAutoFillList(DeviceView * dev, C_Config * config)
|
||||
{
|
||||
// Settings for an autofill
|
||||
int lastAutofill=config->ReadInt(L"LastAutoFill",(int)time(NULL));
|
||||
int fillpc = config->ReadInt(L"FillPercent",90);; // fill device 90% full.
|
||||
bool byAlbum = dev->dev->getDeviceCapacityTotal() > (__int64)1500000000;
|
||||
byAlbum = config->ReadInt(L"AlbumAutoFill",byAlbum?1:0)==1;
|
||||
wchar_t * afquery = _wcsdup(config->ReadString(L"AutoFillQuery",L"length > 30"));
|
||||
wchar_t * squery = _wcsdup(config->ReadString(L"SyncQuery",L"type = 0"));
|
||||
char * tmp2 = AutoCharDup(config->ReadString(L"AutoFillRatings",L"")); // ratings ratio string (eg "3:1:1:1:0:0")
|
||||
int len = 2*strlen(tmp2)+2;
|
||||
char * tmp = (char*)calloc(len,sizeof(char));
|
||||
strncpy(tmp,tmp2,len); free(tmp2);
|
||||
|
||||
int ratingsRatios[6]={0,0,0,0,0,0,};
|
||||
bool useratings=true;
|
||||
if(tmp[0]==0) useratings=false;
|
||||
int i=0;
|
||||
int ratingsRatiosTotal=0;
|
||||
if(useratings) {
|
||||
int len = strlen(tmp);
|
||||
while(tmp[++i]!=0) if(tmp[i]==':') tmp[i]=0;
|
||||
tmp[i+1]=0;
|
||||
char * p = &tmp[0];
|
||||
for(i=0; i<6; i++) {
|
||||
if(p > len + tmp) break;
|
||||
if(*p == 0) break;
|
||||
ratingsRatios[i] = atoi_NULLOK(p);
|
||||
ratingsRatiosTotal+=ratingsRatios[i];
|
||||
p+=strlen(p)+1;
|
||||
}
|
||||
}
|
||||
if(ratingsRatiosTotal==0) {
|
||||
ratingsRatiosTotal=6;
|
||||
for(i=0; i<6; i++) ratingsRatios[i]=1;
|
||||
}
|
||||
|
||||
//construct query
|
||||
wchar_t query[2048]=L"";
|
||||
if(afquery[0]==0) wsprintf(query,L"%s",squery);
|
||||
else wsprintf(query,L"(%s) AND (%s)",squery,afquery);
|
||||
|
||||
//run query
|
||||
itemRecordListW *items = 0;
|
||||
itemRecordListW *results = AGAVE_API_MLDB?AGAVE_API_MLDB->Query(query):0;
|
||||
if (results)
|
||||
{
|
||||
C_ItemList * songList = new C_ItemList;
|
||||
|
||||
if(!byAlbum) autoFill_songfilter(dev->dev,songList, results);
|
||||
else autoFill_albumfilter(dev->dev,songList, results);
|
||||
|
||||
//dump into ratings "bins"
|
||||
C_ItemList * songs[7];
|
||||
for(i=0; i<7; i++) songs[i] = new C_ItemList;
|
||||
for(i=0; i<songList->GetSize(); i++) {
|
||||
if(useratings) {
|
||||
int rating = ((AutoFillItem*)songList->Get(i))->rating;
|
||||
switch (rating) {
|
||||
case 1: songs[1]->Add(songList->Get(i)); break;
|
||||
case 2: songs[2]->Add(songList->Get(i)); break;
|
||||
case 3: songs[3]->Add(songList->Get(i)); break;
|
||||
case 4: songs[4]->Add(songList->Get(i)); break;
|
||||
case 5: songs[5]->Add(songList->Get(i)); break;
|
||||
default: songs[0]->Add(songList->Get(i)); break;
|
||||
}
|
||||
} else songs[0]->Add(songList->Get(i));
|
||||
}
|
||||
|
||||
for(i=0; i<6; i++)
|
||||
{
|
||||
randomizeList(songs[i]->GetAll(),songs[i]->GetSize(),sizeof(void*)); // randomize
|
||||
qsort(songs[i]->GetAll(),songs[i]->GetSize(),sizeof(void*),sortFunc_autofill); // sort by date
|
||||
}
|
||||
|
||||
|
||||
__int64 sizeToFill, totalSize=0;
|
||||
|
||||
sizeToFill = (((__int64)fillpc) * dev->dev->getDeviceCapacityTotal()) / ((__int64)100);
|
||||
//sizeToFill = dev->dev->getDeviceCapacityTotal();
|
||||
|
||||
C_ItemList * alreadyIn = new C_ItemList;
|
||||
C_ItemList * notGoingIn = new C_ItemList;
|
||||
C_ItemList * songsToSend = new C_ItemList;
|
||||
|
||||
if(!byAlbum) {
|
||||
|
||||
int numTracks = dev->dev->getPlaylistLength(0);
|
||||
/* Hmm. This should make autofill just replace selected songs
|
||||
** gonna leave it out for now, until i have good ipod shuffle (et al) support.
|
||||
C_ItemList * selected = getSelectedItems(false);
|
||||
int j=0;
|
||||
if(selected) {
|
||||
if(selected->GetSize() > 0 && selected->GetSize() < numTracks) {
|
||||
for(i=0; i<numTracks; i++) {
|
||||
if(j < selected->GetSize()) if((songid_t)selected->Get(j) == dev->dev->getPlaylistTrack(0,i)) {
|
||||
j++;
|
||||
notGoingIn->Add(selected->Get(j));
|
||||
} else alreadyIn->Add(dev->dev->getPlaylistTrack(0,i));
|
||||
}
|
||||
}
|
||||
delete selected;
|
||||
}
|
||||
*/
|
||||
// otherwise replace ones played since last autofill, unless none played, in which case replace all
|
||||
if(notGoingIn->GetSize() == 0) {
|
||||
delete alreadyIn;
|
||||
alreadyIn = new C_ItemList;
|
||||
if(lastAutofill > 0)
|
||||
{
|
||||
for(i=0; i<numTracks; ++i)
|
||||
if(dev->dev->getTrackLastPlayed(dev->dev->getPlaylistTrack(0,i)) >= lastAutofill) break;
|
||||
|
||||
if (i >= numTracks) // this means nothing has been played, so in this case we set everything to be replaced
|
||||
{
|
||||
for(i=0; i<numTracks; ++i) notGoingIn->Add((void*)dev->dev->getPlaylistTrack(0,i));
|
||||
}
|
||||
else
|
||||
{
|
||||
for(i=0; i < numTracks; ++i)
|
||||
{
|
||||
songid_t s = dev->dev->getPlaylistTrack(0,i);
|
||||
if(dev->dev->getTrackLastPlayed(s) <= lastAutofill) alreadyIn->Add((void*)s);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//remove our already selected songs from the bins
|
||||
for(i=0; i<notGoingIn->GetSize(); ++i) {
|
||||
songid_t s = (songid_t)notGoingIn->Get(i);
|
||||
for (int b=0; b < 6; b ++)
|
||||
{
|
||||
for(int j=0; j<songs[b]->GetSize(); ++j)
|
||||
{
|
||||
if(!compareItemRecordAndSongId(((AutoFillItem *)songs[b]->Get(j))->ice,s, dev->dev))
|
||||
{ // FUCKO
|
||||
songs[6]->Add(songs[b]->Get(j));
|
||||
songs[b]->Del(j);
|
||||
b=6;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for(i=0; i<alreadyIn->GetSize(); ++i) {
|
||||
songid_t s = (songid_t)alreadyIn->Get(i);
|
||||
for (int b= 0; b < 6; b ++)
|
||||
{
|
||||
for(int j=0; j<songs[b]->GetSize(); ++j)
|
||||
{
|
||||
if(!compareItemRecordAndSongId(((AutoFillItem *)songs[b]->Get(j))->ice,s, dev->dev))
|
||||
{
|
||||
songsToSend->Add(((AutoFillItem *)songs[b]->Get(j))->ice);
|
||||
songs[b]->Del(j);
|
||||
b=6;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__int64 size = (__int64)dev->dev->getTrackSize(s);
|
||||
|
||||
if(totalSize + size >= sizeToFill) break;
|
||||
totalSize += size;
|
||||
}
|
||||
} // end if(!byAlbum)
|
||||
|
||||
//select the rest!
|
||||
C_ItemList * albumsToSend = new C_ItemList;
|
||||
|
||||
while(true) {
|
||||
int bin=0;
|
||||
if (useratings)
|
||||
{
|
||||
int val = genrand_int31() % ratingsRatiosTotal;
|
||||
bin=-1;
|
||||
while(val>=0 && bin < 5) val -= ratingsRatios[++bin];
|
||||
|
||||
if (bin > 5) bin=5;
|
||||
else if(bin<0) bin=0;
|
||||
|
||||
bin = 5-bin; // work in reverse mapped bin now (since ratingsRatio is 5-0)
|
||||
|
||||
int sbin=bin;
|
||||
while(bin<6&&songs[bin]->GetSize()<=0) { bin++; } // if our bin is empty, go to a higher bin
|
||||
|
||||
if (bin > 5) // out of higher rated bins, go lower
|
||||
{
|
||||
bin=sbin-1; // start at one lower than where we started
|
||||
while (bin >= 0 && songs[bin]->GetSize()<=0) bin--; // if our bin is still empty, go to a lower bin
|
||||
}
|
||||
|
||||
if (bin < 0) bin = 6;
|
||||
} else bin = songs[0]->GetSize()?0:6;
|
||||
if(!songs[bin])
|
||||
break;
|
||||
int bsize=songs[bin]->GetSize();
|
||||
if (bsize<1)
|
||||
break;
|
||||
|
||||
// JF> will had a %(bsize/2) here effectively, which I think is too major.
|
||||
// I propose a nice simple weighted thing, where stuff near the beginning is more likely
|
||||
// to be picked.
|
||||
int snum = genrand_int31() % bsize;
|
||||
if (genrand_int31()&1) snum/=2; // half the time, just use the first half (less recently played items)
|
||||
|
||||
int size = ((AutoFillItem *)songs[bin]->Get(snum))->size;
|
||||
if(size <= 0)
|
||||
{
|
||||
songs[bin]->Del(snum);
|
||||
continue;
|
||||
}
|
||||
totalSize += (__int64)size;
|
||||
|
||||
/*{
|
||||
wchar_t buf[100] = {0};
|
||||
wsprintf(buf,L"not full. must fill: %d, so far: %d, this track: %d",(int)sizeToFill,(int)totalSize,(int)size);
|
||||
OutputDebugString(buf);
|
||||
}*/
|
||||
|
||||
if(totalSize >= sizeToFill)
|
||||
{
|
||||
/*OutputDebugString(L"full");*/
|
||||
break;
|
||||
}
|
||||
|
||||
if(byAlbum) {
|
||||
albumsToSend->Add(((AutoFillItem *)songs[bin]->Get(snum))->albumName);
|
||||
} else {
|
||||
songsToSend->Add(((AutoFillItem *)songs[bin]->Get(snum))->ice);
|
||||
}
|
||||
songs[bin]->Del(snum);
|
||||
}
|
||||
|
||||
// dump our albums into songsToSend
|
||||
if(albumsToSend->GetSize() > 0)
|
||||
autoFill_addAlbums(albumsToSend, results, songsToSend);
|
||||
|
||||
items = new itemRecordListW;
|
||||
items->Alloc = songsToSend->GetSize();
|
||||
items->Size = songsToSend->GetSize();
|
||||
items->Items = (itemRecordW*)calloc(items->Alloc, sizeof(itemRecordW));
|
||||
|
||||
for(i=0; i<songsToSend->GetSize(); ++i) copyRecord(&items->Items[i],(itemRecordW*)songsToSend->Get(i));
|
||||
|
||||
// clear stuff up
|
||||
for(i=0; i < songList->GetSize(); i++) free(songList->Get(i));
|
||||
for(i=0; i<7; ++i) delete songs[i];
|
||||
delete songsToSend;
|
||||
delete albumsToSend;
|
||||
delete songList;
|
||||
|
||||
delete notGoingIn;
|
||||
delete alreadyIn;
|
||||
|
||||
AGAVE_API_MLDB->FreeRecordList(results); //free memory
|
||||
}
|
||||
|
||||
free(afquery);
|
||||
free(squery);
|
||||
free(tmp);
|
||||
|
||||
return items;
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue