winamp/Src/Plugins/General/gen_ff/AlbumArt.cpp

#include "precomp__gen_ff.h"

#include <api/core/api_core.h>
#include "main.h"
#include "AlbumArt.h"
#include "wa2frontend.h"
#include <api.h>
#include <tataki/bitmap/bitmap.h>
#include <api\wnd\notifmsg.h>
#include <api/script/scriptmgr.h>
#include <api/script/script.h>

#define ALBUMART_MAX_THREADS 4

const wchar_t albumArtXuiObjectStr[] = L"AlbumArt"; // This is the xml tag
char albumArtXuiSvcName[] = "Album Art XUI object"; // this is the name of the xuiservice

AlbumArtScriptController _albumartController;
AlbumArtScriptController *albumartController = &_albumartController;

BEGIN_SERVICES( wa2AlbumArt_Svcs );
DECLARE_SERVICE( XuiObjectCreator<AlbumArtXuiSvc> );
END_SERVICES( wa2AlbumArt_Svcs, _wa2AlbumArt_Svcs );

// --------------------------------------------------------
// Maki Script Object
// --------------------------------------------------------

// -- Functions table -------------------------------------
function_descriptor_struct AlbumArtScriptController::exportedFunction[] = {
	{L"refresh", 0, (void *)AlbumArt::script_vcpu_refresh },
	{L"onAlbumArtLoaded", 1, (void *)AlbumArt::script_vcpu_onAlbumArtLoaded },
	{L"isLoading", 0, (void *)AlbumArt::script_vcpu_isLoading },
};

const wchar_t *AlbumArtScriptController::getClassName()
{
	return L"AlbumArtLayer";
}

const wchar_t *AlbumArtScriptController::getAncestorClassName()
{
	return L"Layer";
}

ScriptObject *AlbumArtScriptController::instantiate()
{
	AlbumArt *a = new AlbumArt;

	ASSERT( a != NULL );

	return a->getScriptObject();
}

void AlbumArtScriptController::destroy( ScriptObject *o )
{
	AlbumArt *a = static_cast<AlbumArt *>( o->vcpu_getInterface( albumArtGuid ) );

	ASSERT( a != NULL );

	delete a;
}

void *AlbumArtScriptController::encapsulate( ScriptObject *o )
{
	return NULL; // no encapsulation yet
}

void AlbumArtScriptController::deencapsulate( void *o )
{}

int AlbumArtScriptController::getNumFunctions()
{
	return sizeof( exportedFunction ) / sizeof( function_descriptor_struct );
}

const function_descriptor_struct *AlbumArtScriptController::getExportedFunctions()
{
	return exportedFunction;
}

GUID AlbumArtScriptController::getClassGuid()
{
	return albumArtGuid;
}


XMLParamPair AlbumArt::params[] =
{
	{ALBUMART_NOTFOUNDIMAGE, L"NOTFOUNDIMAGE"},
	{ALBUMART_SOURCE,        L"SOURCE"},
	{ALBUMART_VALIGN,        L"VALIGN"},
	{ALBUMART_ALIGN,         L"ALIGN"},
	{ALBUMART_STRETCHED,     L"STRETCHED"},
	{ALBUMART_NOREFRESH,     L"NOAUTOREFRESH"},
};

class AlbumArtThreadContext
{
	public:
	AlbumArtThreadContext( const wchar_t *_filename, AlbumArt *_wnd )
	{
		/* lazy load these two handles */
		if ( !_wnd->hMainThread )
			_wnd->hMainThread = WASABI_API_APP->main_getMainThreadHandle();

		if ( !_wnd->thread_semaphore )
			_wnd->thread_semaphore = CreateSemaphore( 0, ALBUMART_MAX_THREADS, ALBUMART_MAX_THREADS, 0 );

		wnd      = _wnd;
		iterator = wnd->iterator;
		h        = w = 0;
		bits     = 0;
		filename = _wcsdup( _filename );
	}

	void FreeBits()
	{
		if ( bits )
			WASABI_API_MEMMGR->sysFree( bits );

		bits = 0;
	}

	~AlbumArtThreadContext()
	{
		if ( wnd )
		{
			if ( wnd->thread_semaphore )
				ReleaseSemaphore( wnd->thread_semaphore, 1, 0 );

			wnd->isLoading--;
		}

		free( filename );
	}

	static void CALLBACK AlbumArtNotifyAPC( ULONG_PTR p );
	bool LoadArt();

	int       h;
	int       w;
	ARGB32   *bits;
	LONG      iterator;
	wchar_t  *filename;
	AlbumArt *wnd;
};


AlbumArt::AlbumArt()
{
	getScriptObject()->vcpu_setInterface( albumArtGuid, ( void * )static_cast<AlbumArt *>( this ) );
	getScriptObject()->vcpu_setClassName( L"AlbumArtLayer" );
	getScriptObject()->vcpu_setController( albumartController );

	WASABI_API_MEDIACORE->core_addCallback( 0, this );

	w                 = 0;
	h                 = 0;
	iterator          = 0;
	bits              = 0;
	hMainThread       = 0;
	thread_semaphore  = 0;
	artBitmap         = 0;
	valign            = 0;
	align             = 0;
	stretched         = false;
	missing_art_image = L"winamp.cover.notfound"; // default to this.
	src_file          = L"";
	forceRefresh      = false;
	noAutoRefresh     = false;
	noMakiCallback    = false;
	isLoading         = 0;

	/* register XML parameters */
	xuihandle = newXuiHandle();

	CreateXMLParameters( xuihandle );
}

void AlbumArt::CreateXMLParameters( int master_handle )
{
	//ALBUMART_PARENT::CreateXMLParameters(master_handle);
	int numParams = sizeof( params ) / sizeof( params[ 0 ] );
	hintNumberOfParams( xuihandle, numParams );

	for ( int i = 0; i < numParams; i++ )
		addParam( xuihandle, params[ i ], XUI_ATTRIBUTE_IMPLIED );
}


AlbumArt::~AlbumArt()
{
	WASABI_API_SYSCB->syscb_deregisterCallback( static_cast<MetadataCallbackI *>( this ) );
	WASABI_API_MEDIACORE->core_delCallback( 0, this );

	// wait for all of our threads to finish
	InterlockedIncrement( &iterator ); // our kill switch (will invalidate iterator on all outstanding threads)
	if ( thread_semaphore )
	{
		for ( int i = 0; i < ALBUMART_MAX_THREADS; i++ )
		{
			if ( WaitForMultipleObjectsEx( 1, &thread_semaphore, FALSE, INFINITE, TRUE ) != WAIT_OBJECT_0 )
				i--;
		}
	}

	delete artBitmap;

	if ( bits )
		WASABI_API_MEMMGR->sysFree( bits );

	if ( thread_semaphore )
		CloseHandle( thread_semaphore );

	if ( hMainThread )
		CloseHandle( hMainThread );
}

bool AlbumArt::layer_isInvalid()
{
	return !bits;
}

void CALLBACK AlbumArtThreadContext::AlbumArtNotifyAPC( ULONG_PTR p )
{
	AlbumArtThreadContext *context = (AlbumArtThreadContext *)p;
	if ( context->wnd->iterator == context->iterator )
		context->wnd->ArtLoaded( context->w, context->h, context->bits );
	else
		context->FreeBits();

	delete context;
}

bool AlbumArtThreadContext::LoadArt()
{
	if ( wnd->iterator != iterator )
		return false;

	if ( AGAVE_API_ALBUMART->GetAlbumArt( filename, L"cover", &w, &h, &bits ) != ALBUMART_SUCCESS )
	{
		bits = 0;
		w    = 0;
		h    = 0;
	}

	if ( wnd->iterator == iterator ) // make sure we're still valid
	{
		QueueUserAPC( AlbumArtNotifyAPC, wnd->hMainThread, (ULONG_PTR)this );

		return true;
	}
	else
	{
		FreeBits();

		return false;
	}
}

static int AlbumArtThreadPoolFunc( HANDLE handle, void *user_data, intptr_t id )
{
	AlbumArtThreadContext *context = (AlbumArtThreadContext *)user_data;
	if ( context->LoadArt() == false )
	{
		delete context;
	}

	return 0;
}

void AlbumArt::ArtLoaded( int _w, int _h, ARGB32 *_bits )
{
	if ( bits )
		WASABI_API_MEMMGR->sysFree( bits );

	if ( artBitmap )
	{
		delete artBitmap;
		artBitmap = 0;
	}

	bits = _bits;
	w    = _w;
	h    = _h;

	if ( !bits )
	{
		SkinBitmap *albumart = missing_art_image.getBitmap();
		if ( albumart )
		{
			w = albumart->getWidth();
			h = albumart->getHeight();
		}
	}

	deleteRegion();
	makeRegion();
	notifyParent( ChildNotify::AUTOWHCHANGED );
	invalidate();

	// notify maki scripts that albumart has been found or not
	if ( !noMakiCallback && _bits )
	{
		AlbumArt::script_vcpu_onAlbumArtLoaded( SCRIPT_CALL, this->getScriptObject(), MAKE_SCRIPT_BOOLEAN( (int)bits ) );
	}
}

void AlbumArt::onSetVisible( int show )
{
	if ( show )
	{
		corecb_onUrlChange( wa2.GetCurrentFile() );
	}
	else
	{
		if ( bits )
		{
			WASABI_API_MEMMGR->sysFree( bits );

			delete artBitmap;
			artBitmap = 0;
		}

		bits = 0;
	}
}

int AlbumArt::corecb_onUrlChange( const wchar_t *filename )
{
	// Martin> if we call this from maki we want to do a refresh regardless of the albumartlayer being visible or not
	if ( forceRefresh || ( !noAutoRefresh && isVisible() ) )
	{
		isLoading++;

		// Martin > do a check for a specific file, defined via source param
		if ( WCSICMP( src_file, L"" ) )
			filename = src_file;

		InterlockedIncrement( &iterator );
		AlbumArtThreadContext *context = new AlbumArtThreadContext( filename, this );

		// make sure we have an available thread free (wait for one if we don't)
		while ( WaitForMultipleObjectsEx( 1, &thread_semaphore, FALSE, INFINITE, TRUE ) != WAIT_OBJECT_0 )
		{}

		//	int vis__ = isVisible();
		WASABI_API_THREADPOOL->RunFunction( 0, AlbumArtThreadPoolFunc, context, 0, api_threadpool::FLAG_LONG_EXECUTION );
	}

	return 1;
}

int AlbumArt::onInit()
{
	int r = ALBUMART_PARENT::onInit();
	WASABI_API_SYSCB->syscb_registerCallback( static_cast<MetadataCallbackI *>( this ) );

	AlbumArt::corecb_onUrlChange( wa2.GetCurrentFile() );

	return r;
}

int AlbumArt::skincb_onColorThemeChanged( const wchar_t *newcolortheme )
{
	ALBUMART_PARENT::skincb_onColorThemeChanged( newcolortheme );
	invalidate();

	return 0;
}

SkinBitmap *AlbumArt::getBitmap()
{
	if ( artBitmap )
		return artBitmap;

	if ( bits )
	{
		artBitmap = new HQSkinBitmap( bits, w, h );  //TH WDP2-212

		return artBitmap;
	}

	return missing_art_image.getBitmap();
}

void AlbumArt::layer_adjustDest( RECT *r )
{
	if ( !w || !h )
		return;

	if ( stretched )
		return;

	//getClientRect(r);
	// maintain 'square' stretching
	int dstW    = r->right - r->left;
	int dstH    = r->bottom - r->top;
	double aspX = (double)( dstW ) / (double)w;
	double aspY = (double)( dstH ) / (double)h;
	double asp  = min( aspX, aspY );
	int newW    = (int)( w * asp );
	int newH    = (int)( h * asp );

	// Align
	int offsetX = ( dstW - newW ) / 2;
	if ( align == 1 )
		offsetX *= 2;
	else if ( align == -1 )
		offsetX = 0;

	// Valign
	int offsetY = ( dstH - newH ) / 2;
	if ( valign == 1 )
		offsetY *= 2;
	else if ( valign == -1 )
		offsetY = 0;

	r->left   += offsetX;
	r->right   = r->left + newW;
	r->top    += offsetY;
	r->bottom  = r->top + newH;

	// This prevents parts of the image being cut off (if the img has the same dimensions as the rect) on moving/clicking winamp
	// (they will just flicker, but at least they won't stay now)
	// benski> CUT!!! no no no no no this is very bad because this gets called inside layer::onPaint  
	//invalidate();
}
/*
int AlbumArt::getWidth()
{
	RECT r;
	getClientRect(&r);
	getDest(&r);
	return r.right-r.left;
}

int AlbumArt::getHeight()
{
	RECT r;
	getClientRect(&r);
	getDest(&r);
	return r.bottom-r.top;
}
*/
/*
int AlbumArt::onPaint(Canvas *canvas)
{
	ALBUMART_PARENT::onPaint(canvas);
	if (bits)
	{
		SkinBitmap albumart(bits, w, h);
		RECT dst;
		getBufferPaintDest(&dst);
		albumart.stretchToRectAlpha(canvas, &dst, getPaintingAlpha());
	}
	return 1;
}
*/
int AlbumArt::setXuiParam( int _xuihandle, int attrid, const wchar_t *name, const wchar_t *strval )
{
	if ( xuihandle != _xuihandle )
		return ALBUMART_PARENT::setXuiParam( _xuihandle, attrid, name, strval );

	switch ( attrid )
	{
		case ALBUMART_NOTFOUNDIMAGE:
			missing_art_image = strval;
			if ( !bits )
			{
				noMakiCallback = true;
				ArtLoaded( 0, 0, 0 );
				noMakiCallback = false;
			}
			break;
		case ALBUMART_SOURCE:
			src_file = strval;
			AlbumArt::corecb_onUrlChange( wa2.GetCurrentFile() ); // This Param should _always_ hold our current file
			break;
		case ALBUMART_VALIGN:
			if ( !WCSICMP( strval, L"top" ) )
				valign = -1;
			else if ( !WCSICMP( strval, L"bottom" ) )
				valign = 1;
			else
				valign = 0;

			deferedInvalidate();
			break;
		case ALBUMART_ALIGN:
			if ( !WCSICMP( strval, L"left" ) )
				align = -1;
			else if ( !WCSICMP( strval, L"right" ) )
				align = 1;
			else
				align = 0;

			deferedInvalidate();
			break;
		case ALBUMART_STRETCHED:
			if ( !WCSICMP( strval, L"0" ) || !WCSICMP( strval, L"" ) )
				stretched = false;
			else
				stretched = true;

			deferedInvalidate();
			break;
		case ALBUMART_NOREFRESH:
			if ( !WCSICMP( strval, L"0" ) || !WCSICMP( strval, L"" ) )
				noAutoRefresh = false;
			else
				noAutoRefresh = true;
			break;
		default:
			return 0;
	}
	return 1;
}

void AlbumArt::metacb_ArtUpdated( const wchar_t *filename )
{
	// it'd be nice to do this, but we can't guarantee that our file didn't get updated in the process
	//const wchar_t *curFn = wa2.GetCurrentFile();
//	if (curFn && filename && *filename && *curFn && !_wcsicmp(filename, curFn))
	AlbumArt::corecb_onUrlChange( wa2.GetCurrentFile() );
}


scriptVar AlbumArt::script_vcpu_refresh( SCRIPT_FUNCTION_PARAMS, ScriptObject *o )
{
	SCRIPT_FUNCTION_INIT;
	AlbumArt *a = static_cast<AlbumArt *>( o->vcpu_getInterface( albumArtGuid ) );
	if ( a )
	{
		a->forceRefresh = true;
		a->corecb_onUrlChange( wa2.GetCurrentFile() );
		a->forceRefresh = false;
	}
	RETURN_SCRIPT_VOID;
}

scriptVar AlbumArt::script_vcpu_isLoading( SCRIPT_FUNCTION_PARAMS, ScriptObject *o )
{
	SCRIPT_FUNCTION_INIT;
	AlbumArt *a = static_cast<AlbumArt *>( o->vcpu_getInterface( albumArtGuid ) );
	if ( a )
	{
		return MAKE_SCRIPT_BOOLEAN( !!a->isLoading );
	}

	return MAKE_SCRIPT_BOOLEAN( false );
}

scriptVar AlbumArt::script_vcpu_onAlbumArtLoaded( SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar success )
{
	SCRIPT_FUNCTION_INIT
		PROCESS_HOOKS1( o, albumartController, success );
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1( o, success );
}