static int vlclua_playlist_status( lua_State *L )
{
playlist_t *p_playlist = vlclua_get_playlist_internal( L );
PL_LOCK;
switch( playlist_Status( p_playlist ) )
{
case PLAYLIST_STOPPED:
lua_pushliteral( L, "stopped" );
break;
case PLAYLIST_RUNNING:
lua_pushliteral( L, "playing" );
break;
case PLAYLIST_PAUSED:
lua_pushliteral( L, "paused" );
break;
default:
lua_pushliteral( L, "unknown" );
break;
}
PL_UNLOCK;
return 1;
}
/*****************************************************************************
* Run: xosd thread
*****************************************************************************
* This part of the interface runs in a separate thread
*****************************************************************************/
static void Run( intf_thread_t *p_intf )
{
playlist_t *p_playlist;
playlist_item_t *p_item = NULL;
char *psz_display = NULL;
int cancel = vlc_savecancel();
while( true )
{
// Wait for a signal
vlc_restorecancel( cancel );
vlc_mutex_lock( &p_intf->p_sys->lock );
mutex_cleanup_push( &p_intf->p_sys->lock );
while( !p_intf->p_sys->b_need_update )
vlc_cond_wait( &p_intf->p_sys->cond, &p_intf->p_sys->lock );
p_intf->p_sys->b_need_update = false;
vlc_cleanup_run();
// Compute the signal
cancel = vlc_savecancel();
p_playlist = pl_Hold( p_intf );
PL_LOCK;
// If the playlist is empty don't do anything
if( playlist_IsEmpty( p_playlist ) )
{
PL_UNLOCK;
pl_Release( p_intf );
continue;
}
free( psz_display );
int i_status = playlist_Status( p_playlist );
if( i_status == PLAYLIST_STOPPED )
{
psz_display = strdup(_("Stop"));
}
else if( i_status == PLAYLIST_PAUSED )
{
psz_display = strdup(_("Pause"));
}
else
{
p_item = playlist_CurrentPlayingItem( p_playlist );
if( !p_item )
{
psz_display = NULL;
PL_UNLOCK;
pl_Release( p_intf );
continue;
}
input_item_t *p_input = p_item->p_input;
mtime_t i_duration = input_item_GetDuration( p_input );
if( i_duration != -1 )
{
char psz_durationstr[MSTRTIME_MAX_SIZE];
secstotimestr( psz_durationstr, i_duration / 1000000 );
if( asprintf( &psz_display, "%s (%s)", p_input->psz_name, psz_durationstr ) == -1 )
psz_display = NULL;
}
else
psz_display = strdup( p_input->psz_name );
}
PL_UNLOCK;
pl_Release( p_intf );
/* Display */
xosd_display( p_intf->p_sys->p_osd, 0, /* first line */
XOSD_string, psz_display );
}
}
static LRESULT HandleCadMessage(intf_thread_t* p_intf, HWND hwnd, WPARAM wParam, LPARAM lParam)
{
intf_sys_t* const p_sys = p_intf->p_sys;
switch (lParam)
{
case IPC_PLAY:
{
playlist_Play(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_PLAYPAUSE:
{
playlist_t* p_playlist = pl_Get(p_intf->p_libvlc);
const bool playing = playlist_Status(p_playlist) == PLAYLIST_RUNNING;
playlist_Control(p_playlist, playing ? PLAYLIST_PAUSE : PLAYLIST_PLAY, pl_Unlocked);
return 1;
}
case IPC_PAUSE:
{
playlist_Pause(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_STOP:
{
playlist_Stop(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_NEXT:
{
playlist_Next(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_PREVIOUS:
{
playlist_Prev(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_SET_VOLUME:
{
playlist_VolumeSet(pl_Get(p_intf->p_libvlc), (int)wParam / 100.0f);
return 1;
}
case IPC_GET_VOLUME:
{
// VLC can return a volume larger than 100% so we need to cap it to 100 here.
const float volume = playlist_VolumeGet(pl_Get(p_intf->p_libvlc)) * 100.0f;
return (LRESULT)min(volume, 100.0f);
}
case IPC_GET_DURATION:
{
unsigned int duration = 0;
if (p_sys->p_input)
{
input_item_t* const p_item = input_GetItem(p_sys->p_input);
duration = (unsigned int)(input_item_GetDuration(p_item) / 1000000);
}
return duration;
}
case IPC_GET_POSITION:
{
int pos = 0;
if (p_sys->p_input)
{
pos = (int)(var_GetTime(p_sys->p_input, "time") / CLOCK_FREQ);
}
return pos;
}
case IPC_SET_POSITION:
{
if (p_sys->p_input)
{
var_SetTime(p_sys->p_input, "time", (int64_t)wParam * CLOCK_FREQ);
}
return 0;
}
case IPC_GET_SHUFFLE:
{
return (int)var_GetBool(pl_Get(p_intf->p_libvlc), "random");
}
case IPC_SET_SHUFFLE:
{
return (int)var_SetBool(pl_Get(p_intf->p_libvlc), "random", (bool)wParam);
}
case IPC_GET_REPEAT:
{
return (int)var_GetBool(pl_Get(p_intf->p_libvlc), "repeat");
}
case IPC_SET_REPEAT:
{
return (int)var_SetBool(pl_Get(p_intf->p_libvlc), "repeat", (bool)wParam);
}
case IPC_SET_RATING:
{
// VLC does not support ratings so send back 0.
PostMessage(p_sys->cad_window, WM_USER, 0, IPC_RATING_CHANGED_NOTIFICATION);
return 0;
}
case IPC_SET_CALLBACK_HWND:
{
p_sys->cad_window = (HWND)wParam;
return 1;
}
case IPC_SHOW_WINDOW:
{
// TODO.
return 0;
}
case IPC_GET_STATE:
{
const int status = playlist_Status(pl_Get(p_intf->p_libvlc));
return
status == PLAYLIST_RUNNING ? 1 :
status == PLAYLIST_PAUSED ? 2 :
0;
}
case IPC_SHUTDOWN_NOTIFICATION:
{
p_sys->cad_window = NULL;
return 1;
}
case IPC_CLOSE:
{
libvlc_Quit(p_intf->p_libvlc);
return 1;
}
case IPC_GET_CURRENT_TRACK:
{
if (!p_sys->p_input) return 0;
input_item_t* p_item = input_GetItem(p_sys->p_input);
char buffer[DATA_MAX_LENGTH];
int buffer_len = 0;
// If the i sstarts with file://, we assume that it is a local file and detailed
// metadata is available. Otherwise, we assume it to be a network stream (i.e. radio)
// with limited info (only a title).
char* const file = decode_URI(input_item_GetURI(p_item));
if (strncmp(file, "file://", 7) == 0)
{
char* const title = input_item_GetTitleFbName(p_item);
char* const artist = input_item_GetArtist(p_item);
char* const album = input_item_GetAlbum(p_item);
char* const cover = decode_URI(input_item_GetArtworkURL(p_item));
const unsigned int duration = input_item_GetDuration(p_item) / 1000000U;
buffer_len = _snprintf(
buffer, ARRAYSIZE(buffer), "%s\t%s\t%s\t\t\t\t\t%u\t%s\t\t%s\t\t\t\t\t\t\t",
title ? title : "",
artist ? artist : "",
album ? album : "",
duration,
file ? &file[8] : "",
cover ? &cover[8] : ""); // Skip the "file://" part.
free(title);
free(artist);
free(album);
free(cover);
}
else if (char* now_playing = input_item_GetNowPlaying(p_item))
{
char* artist = NULL;
char* title = now_playing;
char* pos = strstr(now_playing, " - ");
if (pos)
{
pos[0] = '\0';
artist = title;
title = pos + 3; // Skip the " - "
}
buffer_len = _snprintf(
buffer, ARRAYSIZE(buffer), "%s\t%s\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t",
title ? title : "",
artist ? artist : "");
free(now_playing);
}
free(file);
if (buffer_len)
{
wchar_t buffer_w[DATA_MAX_LENGTH];
const int buffer_w_len = MultiByteToWideChar(
CP_UTF8, 0, buffer, buffer_len + 1, buffer_w, ARRAYSIZE(buffer_w));
COPYDATASTRUCT cds;
cds.dwData = IPC_CURRENT_TRACK_NOTIFICATION;
cds.lpData = &buffer_w;
cds.cbData = buffer_w_len * sizeof(buffer_w[0]);
SendMessage(
p_sys->cad_window, WM_COPYDATA, IPC_CURRENT_TRACK_NOTIFICATION, (LPARAM)&cds);
}
return 1;
}
}
return 0;
}
