winamp/Src/Plugins/Library/ml_pmp/autofill.cpp

/*
** 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;
}