bool Codec::Init(const CStdString & strFile, unsigned int filecache) {
m_bufferSize = 2048 * sizeof(int16_t) * 50;
m_buffer = new char[m_bufferSize];
CStdString uri = URIUtils::GetFileName(strFile);
CStdString extension = uri.Right(uri.GetLength() - uri.Find('.') - 1);
if (extension.Left(12) == "spotifyradio") {
//if its a radiotrack the radionumber and tracknumber is secretly encoded at the end of the extension
CStdString trackStr = extension.Right(
extension.GetLength() - extension.ReverseFind('#') - 1);
Logger::printOut(extension);
CStdString radioNumber = extension.Left(uri.Find('#'));
Logger::printOut(radioNumber);
radioNumber = radioNumber.Right(
radioNumber.GetLength() - radioNumber.Find('#') - 1);
Logger::printOut("loading codec radio");
RadioHandler::getInstance()->pushToTrack(atoi(radioNumber),
atoi(trackStr));
}
//we have a non legit extension so remove it manually
uri = uri.Left(uri.Find('.'));
Logger::printOut("trying to load track:");
Logger::printOut(uri);
sp_link *spLink = sp_link_create_from_string(uri);
m_currentTrack = sp_link_as_track(spLink);
sp_track_add_ref(m_currentTrack);
sp_link_release(spLink);
m_endOfTrack = false;
m_bufferPos = 0;
m_startStream = false;
m_isPlayerLoaded = false;
m_TotalTime = sp_track_duration(m_currentTrack);
//prefetch the next track!
CPlayList& playlist = g_playlistPlayer.GetPlaylist(PLAYLIST_MUSIC);
int nextSong = g_playlistPlayer.GetNextSong();
if (nextSong >= 0 && nextSong < playlist.size()){
CFileItemPtr song = playlist[nextSong];
if (song != NULL){
CStdString uri = song->GetPath();
if (uri.Left(7).Equals("spotify")){
uri = uri.Left(uri.Find('.'));
Logger::printOut("prefetching track:");
Logger::printOut(uri);
sp_link *spLink = sp_link_create_from_string(uri);
sp_track* track = sp_link_as_track(spLink);
sp_session_player_prefetch(getSession(), track);
sp_link_release(spLink);
}
}
}
return true;
}
//----------------------------------------------
// get track info from URI
//----------------------------------------------
TRef TLSpotify::TSession::FindTrack(const TString& URI)
{
THeapArray<char> UriString;
URI.GetAnsi( UriString );
// find link
sp_link *link = sp_link_create_from_string( UriString.GetData() );
if (!link)
return TRef();
// get track from the link
sp_track* pTrack = sp_link_as_track( link );
if ( !pTrack )
{
TDebugString Debug_String;
Debug_String << "URI " << URI << " is not a track";
TLDebug_Print( Debug_String );
return TRef();
}
// create new track info
TRef TrackRef = AddTrack( *pTrack );
const char* TrackName = sp_track_name( pTrack );
// The create function will have increased the reference count for us so release
sp_link_release(link);
return TrackRef;
}
PHP_METHOD(Spotify, getTrackByURI)
{
zval *uri, temp, *object = getThis();
int timeout = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &uri) == FAILURE) {
return;
}
spotify_object *p = (spotify_object*)zend_object_store_get_object(object TSRMLS_CC);
sp_link *link = sp_link_create_from_string(Z_STRVAL_P(uri));
if (NULL == link) {
RETURN_FALSE;
}
if (SP_LINKTYPE_TRACK != sp_link_type(link)) {
RETURN_FALSE;
}
sp_track *track = sp_link_as_track(link);
while (!sp_track_is_loaded(track)) {
sp_session_process_events(p->session, &timeout);
}
object_init_ex(return_value, spotifytrack_ce);
SPOTIFY_METHOD2(SpotifyTrack, __construct, &temp, return_value, object, track);
sp_link_release(link);
}
void Spotify::changeCurrentlyPlayingSong()
{
sp_track * track;
const char * uri = currentURI.toLocal8Bit().constData();
fprintf(stderr, "Spotify: Playing %s\n", uri);
sp_link * link = sp_link_create_from_string(uri);
if (!link) {
fprintf(stderr, "Spotify: failed to parse URI (%s)\n", uri);
currentURI.clear();
return;
}
switch (sp_link_type(link)) {
case SP_LINKTYPE_LOCALTRACK:
case SP_LINKTYPE_TRACK:
track = sp_link_as_track(link);
if (!track) {
fprintf(stderr, "Link is not a track\n");
break;
}
nextTrack = track;
sp_track_add_ref(track);
tryLoadTrack();
break;
default:
qDebug() << "URI is not a track:" << currentURI;
break;
}
sp_link_release(link);
}
QString Spotify::songNameFromUri(const QString &uriString)
{
const char * uri = uriString.toLocal8Bit().constData();
sp_link * link = sp_link_create_from_string(uri);
if (!link) {
fprintf(stderr, "Spotify: failed to parse URI (%s)\n", uri);
return QString();
}
sp_track * track;
QString song;
switch (sp_link_type(link)) {
case SP_LINKTYPE_LOCALTRACK:
case SP_LINKTYPE_TRACK:
track = sp_link_as_track(link);
if (!track) {
fprintf(stderr, "Link is not a track\n");
break;
}
song = QString(sp_track_name(track));
break;
default:
qDebug() << "URI is not a track:" << uriString;
break;
}
sp_link_release(link);
return song;
}
char* print_queue()
{
int json_size = 1024;
char* json = malloc(json_size * sizeof(char));
memset(json, '\0', json_size * sizeof(char));
strcpy(json, "{\"queue\":[");
songInQueue* temp = firstSong;
while (temp != NULL && temp->song != NULL)
{
if (temp->song == NULL) {
printf("Warning: song was null for enqueued track.\n");
fflush(stdout);
}
sp_track *track = sp_link_as_track(temp->song);
if (track == NULL) {
fprintf(stderr, "link was not for a track.\n");
return NULL;
}
if (!track_to_json(track, &json, &json_size, temp->nVotes)) {
fprintf(stderr, "Failed to set track info in JSON buffer\n");
return NULL;
}
// if it's not the last element in the queue, print a comma
if (temp->next != NULL) {
strcat_resize(&json, &json_size, ",");
}
temp = temp->next;
//sp_track_release(track);
}
strcat_resize(&json, &json_size, "]}");
return json;
}
JNIEXPORT jobject JNICALL Java_jahspotify_impl_JahSpotifyImpl_retrieveTrack ( JNIEnv *env, jobject obj, jstring uri)
{
jobject trackInstance;
uint8_t *nativeUri = NULL;
nativeUri = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, uri, NULL );
sp_link *link = sp_link_create_from_string(nativeUri);
if (!link)
{
// hmm
fprintf ( stderr, "jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrieveTrack: Could not create link!\n" );
return JNI_FALSE;
}
sp_track *track = sp_link_as_track(link);
while (!sp_track_is_loaded(track))
{
fprintf ( stderr, "jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrieveTrack: Waiting for track to be loaded ...\n" );
sleep(1);
}
trackInstance = createJTrackInstance(env, track);
if (track)
sp_track_release(track);
if (link)
sp_link_release(link);
if (nativeUri)
free(nativeUri);
return trackInstance;
}
/**
* This callback is called when an attempt to login has succeeded or failed.
*
* @sa sp_session_callbacks#logged_in
*/
static void logged_in(sp_session *sess, sp_error error)
{
sp_link *link;
if (SP_ERROR_OK != error) {
fprintf(stderr, "Login failed: %s\n",
sp_error_message(error));
exit(2);
}
printf("Loading track\n");
link = sp_link_create_from_string("spotify:track:5W3cjX2J3tjhG8zb6u0qHn");
sp_track_add_ref(g_currenttrack = sp_link_as_track(link));
sp_link_release(link);
if (sp_track_error(g_currenttrack) == SP_ERROR_OK) {
printf("Now playing \"%s\"...\n", sp_track_name(g_currenttrack));
fflush(stdout);
sp_session_player_load(g_sess, g_currenttrack);
sp_session_player_play(g_sess, 1);
}
/* Track not loaded? Then we need to wait for the metadata to
load before we can start playback (see below) */
}
int cmd_playlist_add_track(int argc, char **argv)
{
sp_link *plink, *tlink;
sp_track *t;
sp_playlist *pl;
int i;
struct pl_update_work *puw;
if(argc < 4) {
printf("add [playlist uri] [position] [track uri] <[track uri]>...\n");
return 1;
}
plink = sp_link_create_from_string(argv[1]);
if (!plink) {
fprintf(stderr, "%s is not a spotify link\n", argv[1]);
return -1;
}
if(sp_link_type(plink) != SP_LINKTYPE_PLAYLIST) {
fprintf(stderr, "%s is not a playlist link\n", argv[1]);
sp_link_release(plink);
return -1;
}
puw = malloc(sizeof(struct pl_update_work));
puw->position = atoi(argv[2]);
puw->tracks = malloc(sizeof(sp_track *) * argc - 3);
puw->num_tracks = 0;
for(i = 0; i < argc - 3; i++) {
tlink = sp_link_create_from_string(argv[i + 3]);
if(tlink == NULL) {
fprintf(stderr, "%s is not a spotify link, skipping\n", argv[i + 3]);
continue;
}
if(sp_link_type(tlink) != SP_LINKTYPE_TRACK) {
fprintf(stderr, "%s is not a track link, skipping\n", argv[i + 3]);
continue;
}
t = sp_link_as_track(tlink);
sp_track_add_ref(t);
puw->tracks[puw->num_tracks++] = t;
sp_link_release(tlink);
}
pl = sp_playlist_create(g_session, plink);
if(!apply_changes(pl, puw)) {
// Changes applied directly, we're done
sp_playlist_release(pl);
sp_link_release(plink);
return 1;
}
fprintf(stderr, "Playlist not yet loaded, waiting...\n");
sp_playlist_add_callbacks(pl, &pl_update_callbacks, puw);
sp_link_release(plink);
return 0;
}
int createTrackFromUri( char *uri , char *name )
{
TRACE_2( PLAYERMANAGER , "createTrackFromUri( %s , __track__ )" , uri );
sp_link *link;
sp_error error;
if( playing == FALSE && hasNextTrack() == FALSE )
createFile( name );
TRACE_1( PLAYERMANAGER , "Creating URI : %s" , uri );
link = sp_link_create_from_string( uri );
if( link == NULL )
{
TRACE_ERROR( PLAYERMANAGER , "Fail to create link.");
return PC_ERROR;
}
else
{
TRACE_1( PLAYERMANAGER , "Success to create link.");
}
TRACE_3( PLAYERMANAGER , "Construct track...");
currentTrack = sp_link_as_track( link );
if( currentTrack == NULL )
{
TRACE_ERROR( PLAYERMANAGER , "Fail to create track.");
return PC_ERROR;
}
else
{
TRACE_1( PLAYERMANAGER , "Success to create track.");
}
error = sp_track_add_ref( currentTrack );
if( error != SP_ERROR_OK )
{
TRACE_ERROR( PLAYERMANAGER , "Cannot add ref track, reason: %s" , sp_error_message( error ) );
return PC_ERROR;
}
sp_link_release( link );
running = TRUE;
// playing = FALSE;
return PC_SUCCESS;
}
bool Codec::Init(const CStdString & strFile, unsigned int filecache) {
m_bufferSize = 2048 * sizeof(int16_t) * 50;
m_buffer = new char[m_bufferSize];
CStdString uri = URIUtils::GetFileName(strFile);
CStdString extension = uri.Right(uri.GetLength() - uri.Find('.') - 1);
//we have a non legit extension so remove it manually
uri = uri.Left(uri.Find('.'));
Logger::printOut("trying to load track:");
Logger::printOut(uri);
sp_link *spLink = sp_link_create_from_string(uri);
m_currentTrack = sp_link_as_track(spLink);
sp_track_add_ref(m_currentTrack);
sp_link_release(spLink);
m_endOfTrack = false;
m_bufferPos = 0;
m_startStream = false;
m_isPlayerLoaded = false;
m_TotalTime = sp_track_duration(m_currentTrack);
//prefetch the next track!
CPlayList& playlist = g_playlistPlayer.GetPlaylist(PLAYLIST_MUSIC);
int nextSong = g_playlistPlayer.GetNextSong();
if (nextSong >= 0 && nextSong < playlist.size()){
CFileItemPtr song = playlist[nextSong];
if (song != NULL){
CStdString uri = song->GetPath();
if (uri.Left(7).Equals("spotify")){
uri = uri.Left(uri.Find('.'));
Logger::printOut("prefetching track:");
Logger::printOut(uri);
sp_link *spLink = sp_link_create_from_string(uri);
sp_track* track = sp_link_as_track(spLink);
sp_session_player_prefetch(getSession(), track);
sp_link_release(spLink);
}
}
}
return true;
}
static PyObject *
Link_as_track(Link * self)
{
sp_track *track = sp_link_as_track(self->_link);
if (!track) {
PyErr_SetString(SpotifyError, "Not a track link");
return NULL;
}
PyObject *ptrack = Track_FromSpotify(track);
return ptrack;
}
//sp_track* sp_link_as_track (sp_link *link)
int luasp_link_as_track(lua_State *L) {
// track = spotify.link_as_track(link)
if (lua_gettop(L) != 1 || !lua_isuserdata(L, 1))
{
lua_pushstring(L, "incorrect argument to link_as_track(...)");
lua_error(L);
}
lua_pushlightuserdata(L, sp_link_as_track((sp_link*)lua_touserdata(L, 1)) );
return 1;
}
void QSpotifySession::handleUri(QString uri) {
qDebug() << "QSpotifySession::handleUri";
if (!m_isLoggedIn) {
m_uriToOpen = uri;
return;
}
sp_link *link = sp_link_create_from_string(uri.toLatin1().data());
sp_linktype link_type = sp_link_type(link);
if (link_type == SP_LINKTYPE_TRACK) {
sp_track *track = sp_link_as_track(link);
std::shared_ptr<QSpotifyTrack> q_track(new QSpotifyTrack(track, nullptr));
enqueue(q_track);
play(q_track, true);
}
}
bool json_to_track(json_t *json, sp_track **track) {
if (!json_is_string(json))
return false;
sp_link *link = sp_link_create_from_string(json_string_value(json));
if (link == NULL)
return false;
if (sp_link_type(link) != SP_LINKTYPE_TRACK) {
sp_link_release(link);
return false;
}
*track = sp_link_as_track(link);
return *track != NULL;
}
int cmd_browse(int argc, char **argv)
{
sp_link *link;
if (argc != 2) {
browse_usage();
return -1;
}
link = sp_link_create_from_string(argv[1]);
if (!link) {
fprintf(stderr, "Not a spotify link\n");
return -1;
}
switch(sp_link_type(link)) {
default:
fprintf(stderr, "Can not handle link");
sp_link_release(link);
return -1;
case SP_LINKTYPE_ALBUM:
sp_albumbrowse_create(g_session, sp_link_as_album(link), browse_album_callback, NULL);
break;
case SP_LINKTYPE_ARTIST:
sp_artistbrowse_create(g_session, sp_link_as_artist(link), browse_artist_callback, NULL);
break;
case SP_LINKTYPE_TRACK:
track_browse = sp_link_as_track(link);
metadata_updated_fn = track_browse_try;
sp_track_add_ref(track_browse);
track_browse_try();
break;
case SP_LINKTYPE_PLAYLIST:
browse_playlist(sp_playlist_create(g_session, link));
break;
}
sp_link_release(link);
return 0;
}
// Loads track if metadata exists, otherwise load the metadata
static void load_track_or_metadata(sp_session *session, sp_track *track, const char *uri) {
if (track != NULL) {
if (s_is_playing)
sp_session_player_play(session, false);
sp_session_player_unload(session);
sp_track_release(track);
}
track = sp_link_as_track(sp_link_create_from_string(uri));
set_track(track);
sp_track_add_ref(track);
s_player_position = 0;
s_current_uri = uri;
// either the track is already cached and can be used or we need to wait for the metadata callback
if (sp_track_is_loaded(track))
load_and_play_track(session, track);
else
s_is_waiting_for_metadata = true;
}
static void try_playback_start(void) {
sp_track *t;
if(amtSongs() == 0) {
fprintf(stderr, "Playlist: No tracks in playlist. Waiting\n");
return;
}
t = sp_link_as_track(firstSong->song);
if(g_currenttrack && t != g_currenttrack) {
audio_fifo_flush(&g_audiofifo);
sp_session_player_unload(g_sess);
g_currenttrack = NULL;
}
if(!t) {
printf("Null Song\n");
fflush(stdout);
return;
}
int next_timeout = 0;
sp_session_process_events(g_sess, &next_timeout);
while(sp_track_error(t) != SP_ERROR_OK) {
sp_session_process_events(g_sess, &next_timeout);
printf("Loading Track...\n");
usleep(100000);
}
if(sp_track_error(t) != SP_ERROR_OK) {
printf("SP_ERRoR\n");
printf("%i\n", sp_track_error(t));
fflush(stdout);
return;
}
if(g_currenttrack == t) {
printf("Coninuting same track\n");
fflush(stdout);
return;
}
g_currenttrack = t;
printf("Partyfy: Now playing \"%s\"...\n", sp_track_name(t));
fflush(stdout);
sp_session_player_load(g_sess, t);
sp_session_player_play(g_sess, 1);
}
void command_link(sp_session *session, const struct command * const command)
{
sp_link *l = sp_link_create_from_string(command->search_string);
if(l == NULL || sp_link_type(l) == SP_LINKTYPE_INVALID)
{
sock_send_str(command->sockfd, "Not a valid link.\n");
return;
}
else if(sp_link_type(l) == SP_LINKTYPE_TRACK)
{
sp_track *t = sp_link_as_track(l);
queue_add_track(t);
sock_send_str(command->sockfd, "Added track to queue.\n");
}
else
{
sock_send_str(command->sockfd, "Link is valid but its type is not supported. Only links to tracks are supported.\n");
}
sp_link_release(l);
}
void AudioHTTPServer::sid( QxtWebRequestEvent* event, QString a )
{
qDebug() << QThread::currentThreadId() << "HTTP" << event->url.toString() << a;
if( !SpotifySession::getInstance()->Playback()->trackIsOver() ) {
SpotifySession::getInstance()->Playback()->endTrack();
}
// the requested track
QString uid = a.replace( ".wav", "");
// qDebug() << QThread::currentThreadId() << "Beginning to stream requested track:" << uid;
if( uid.isEmpty() || !sApp->hasLinkFromTrack( uid ) ) {
qWarning() << "Did not find spotify track UID in our list!" << uid;
sendErrorResponse( event );
return;
}
// get the sp_track
sp_link* link = sApp->linkFromTrack( uid );
sp_track* track = sp_link_as_track( link );
if( !track ) {
qWarning() << QThread::currentThreadId() << "Uh oh... got null track from link :(" << sp_link_type( link );
sendErrorResponse( event );
return;
}
if( !sp_track_is_loaded( track ) ) {
qWarning() << QThread::currentThreadId() << "uh oh... track not loaded yet! Asked for:" << sp_track_name( track );
m_savedEvent = event;
m_savedTrack = track;
QTimer::singleShot( 250, this, SLOT( checkForLoaded() ) );
return;
} else {
startStreamingResponse( event, track );
}
}
sp_track *
sp_link_as_track_and_offset(sp_link *link, int *offset)
{
/* parse the offset */
int mins = 0, secs = 0;
char *optr = NULL;
sp_link *my_link = ALLOC(sp_link);
my_link->data = strclone(link->data);
if (optr = strchr(my_link->data, '#'))
{
sscanf(optr, "#%2u:%2u", &mins, &secs);
*offset = (mins * 60 + secs) * 1000;
*optr = '\0';
}
else
{
*offset = 0;
}
return sp_link_as_track(my_link);
}
static gboolean
rbspotifysrc_start (GstBaseSrc *bsrc)
{
RBSpotifySrc *src = RBSPOTIFYSRC (bsrc);
// sp_error err;
sp_link* link;
audio_fifo_t *af = &g_audio_fifo;
// sp_track* track;
// int timeout;
fprintf(stderr, "Playing %s\n", src->uri);
link = sp_link_create_from_string(src->uri);
if (!link)
{
fprintf(stderr, "Couldn't open file");
return FALSE;
}
src->track = sp_link_as_track(link);
if (!src->track)
{
fprintf(stderr, "Couldn't turn link to track %s", src->uri);
return FALSE;
}
sp_track_add_ref(src->track);
sp_link_release(link);
src->tloaded = FALSE;
src->played = 0;
src->curoffset = 0;
audio_fifo_flush(af);
return TRUE;
}
/* only used to trigger sp_session_process_events when needed,
* looks like about once a second */
static void*
spotify_thread_func (void *data)
{
int timeout = -1;
GTimeVal t;
GstSpotSrc *spot = (GstSpotSrc *) data;
if (!spotify_create_session (spot)) {
GST_ERROR_OBJECT (spot, "Create_session error");
return FALSE;
}
while (spot->keep_spotify_thread) {
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
g_get_current_time (&t);
g_time_val_add (&t, timeout * 1000);
g_cond_timed_wait (spot->process_events_cond, spot->process_events_mutex, &t);
spot->spotify_thread_initiated = TRUE;
while (spot->spot_works) {
struct spot_work *spot_work;
sp_error ret = SP_ERROR_INVALID_INDATA;
spot_work = (struct spot_work *)spot->spot_works->data;
g_mutex_lock (spot_work->spot_mutex);
switch (spot_work->cmd) {
case SPOT_CMD_START:
GST_DEBUG_OBJECT (spot, "Uri = %s", GST_SPOT_SRC_URI_LOCATION (spot));
if (!spotify_login (spot)) {
/* error message from within function */
break;
}
sp_link *link = sp_link_create_from_string (GST_SPOT_SRC_URI_LOCATION (spot));
if (!link) {
GST_ERROR_OBJECT (spot, "Incorrect track ID:%s", GST_SPOT_SRC_URI_LOCATION (spot));
break;
}
GST_SPOT_SRC_CURRENT_TRACK (spot) = sp_link_as_track (link);
if (!GST_SPOT_SRC_CURRENT_TRACK (spot)) {
GST_ERROR_OBJECT (spot, "Could get track from uri=%s", GST_SPOT_SRC_URI_LOCATION (spot));
break;
}
#if 0
/* FIXME: why does not this work? */
if (!sp_track_is_available (GST_SPOT_SRC_CURRENT_TRACK (spot))) {
/* this probably happens for tracks avaiable in other countries or
something */
GST_ERROR_OBJECT (spot, "Track is not available, uri=%s", GST_SPOT_SRC_URI_LOCATION (spot));
break;
}
#endif
sp_track_add_ref (GST_SPOT_SRC_CURRENT_TRACK (spot));
sp_link_add_ref (link);
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
while (sp_track_is_loaded (GST_SPOT_SRC_CURRENT_TRACK (spot)) == 0) {
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
usleep (10000);
}
GST_DEBUG_OBJECT (spot, "Now playing \"%s\"", sp_track_name (GST_SPOT_SRC_CURRENT_TRACK (spot)));
ret = sp_session_player_load (GST_SPOT_SRC_SPOTIFY_SESSION (spot), GST_SPOT_SRC_CURRENT_TRACK (spot));
if (ret != SP_ERROR_OK) {
GST_ERROR_OBJECT (spot, "Failed to load track '%s' uri=%s", sp_track_name (GST_SPOT_SRC_CURRENT_TRACK (spot)),
(GST_SPOT_SRC_URI_LOCATION (spot)));
break;
}
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
ret = sp_session_player_play (GST_SPOT_SRC_SPOTIFY_SESSION (spot), TRUE);
if (ret != SP_ERROR_OK) {
GST_ERROR_OBJECT (spot, "Failed to play track '%s' uri=%s", sp_track_name (GST_SPOT_SRC_CURRENT_TRACK (spot)),
(GST_SPOT_SRC_URI_LOCATION (spot)));
break;
}
break;
case SPOT_CMD_PROCESS:
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
break;
case SPOT_CMD_PLAY:
ret = sp_session_player_play (GST_SPOT_SRC_SPOTIFY_SESSION (spot), TRUE);
break;
case SPOT_CMD_DURATION:
if (GST_SPOT_SRC_CURRENT_TRACK (spot)) {
ret = sp_track_duration (GST_SPOT_SRC_CURRENT_TRACK (spot));
}
break;
case SPOT_CMD_STOP:
if (GST_SPOT_SRC_CURRENT_TRACK (spot)) {
ret = sp_session_player_play (GST_SPOT_SRC_SPOTIFY_SESSION (spot), FALSE);
if (ret != SP_ERROR_OK) {
break;
}
ret = SP_ERROR_OK;
sp_session_player_unload (GST_SPOT_SRC_SPOTIFY_SESSION (spot));
}
break;
case SPOT_CMD_SEEK:
if (GST_SPOT_SRC_CURRENT_TRACK (spot)) {
ret = sp_session_player_seek (GST_SPOT_SRC_SPOTIFY_SESSION (spot), spot_work->opt);
}
break;
default:
g_assert_not_reached ();
break;
}
/* print all errors caught and propagate to calling thread */
if (ret != SP_ERROR_OK) {
GST_ERROR_OBJECT (spot, "Failed with SPOT_CMD=%d, ret=%d, error=%s", spot_work->cmd, ret, sp_error_message (ret));
}
spot_work->ret = ret;
spot->spot_works = g_list_remove (spot->spot_works, spot->spot_works->data);
g_mutex_unlock (spot_work->spot_mutex);
g_cond_broadcast (spot_work->spot_cond);
}
}
return NULL;
}
static void restore_state(session_callback_type type, gpointer data, gpointer user_data) {
JsonParser* jp = NULL;
JsonReader* jr = NULL;
const gchar* sqs;
saved_state* s = NULL;
GError* err = NULL;
/* Is it the callback we're interested in? */
if (type != SPOP_SESSION_LOGGED_IN)
return;
/* First disable the callback so it's not called again */
session_remove_callback(restore_state, NULL);
g_debug("savestate: reading saved state...");
s = g_new0(saved_state, 1);
/* Read and parse state file */
jp = json_parser_new();
if (!json_parser_load_from_file(jp, g_state_file_path, &err)) {
g_warning("savestate: error while reading state file: %s", err->message);
goto restorestate_error;
}
jr = json_reader_new(json_parser_get_root(jp));
/* Read basic state */
if (!json_reader_read_member(jr, "status")) goto restorestate_jr_error;
sqs = json_reader_get_string_value(jr);
json_reader_end_member(jr);
if (strcmp(sqs, "stopped")) s->qs = STOPPED;
else if (strcmp(sqs, "playing")) s->qs = PLAYING;
else if (strcmp(sqs, "paused")) s->qs = PAUSED;
else {
g_warning("savestate: bad value for queue status: %s", sqs);
goto restorestate_error;
}
if (!json_reader_read_member(jr, "repeat")) goto restorestate_jr_error;
s->repeat = json_reader_get_boolean_value(jr);
json_reader_end_member(jr);
if (!json_reader_read_member(jr, "shuffle")) goto restorestate_jr_error;
s->shuffle = json_reader_get_boolean_value(jr);
json_reader_end_member(jr);
if (!json_reader_read_member(jr, "current_track")) goto restorestate_jr_error;
s->cur_track = json_reader_get_int_value(jr);
json_reader_end_member(jr);
/* Now read tracks URIs */
if (!json_reader_read_member(jr, "tracks")) goto restorestate_jr_error;
if (!json_reader_is_array(jr)) {
g_warning("savestate: error while parsing JSON: tracks is not an array");
goto restorestate_error;
}
gint tracks = json_reader_count_elements(jr);
if (s->cur_track >= tracks) {
g_warning("savestate: incoherent state file: cur_track >= tracks");
goto restorestate_error;
}
s->tracks = g_array_sized_new(FALSE, FALSE, sizeof(sp_track*), tracks);
if (!s->tracks)
g_error("Can't allocate array of %d tracks.", tracks);
size_t i;
gboolean can_restore_now = TRUE;
for (i=0; i < tracks; i++) {
json_reader_read_element(jr, i);
const gchar* uri = json_reader_get_string_value(jr);
json_reader_end_element(jr);
sp_link* lnk = sp_link_create_from_string(uri);
sp_linktype lt = sp_link_type(lnk);
if (lt != SP_LINKTYPE_TRACK) {
g_warning("savestate: invalid link type for track %zu: %d", i, lt);
sp_link_release(lnk);
goto restorestate_error;
}
sp_track* tr = sp_link_as_track(lnk);
sp_track_add_ref(tr);
sp_link_release(lnk);
g_array_append_val(s->tracks, tr);
if (!sp_track_is_loaded(tr))
can_restore_now = FALSE;
}
/* If possible, restore now, else wait for all tracks to be loaded */
if (can_restore_now)
really_restore_state(s);
else {
g_timeout_add(100, (GSourceFunc) really_restore_state, s);
g_debug("savestate: waiting for all tracks to be loaded before restoring saved state...");
}
/* Add a notification callback */
if (!interface_notify_add_callback(savestate_notification_callback, NULL))
g_error("Could not add savestate callback.");
goto restorestate_clean;
restorestate_jr_error:
err = (GError*) json_reader_get_error(jr);
g_warning("savestate: error while parsing JSON: %s", err->message);
restorestate_error:
if (s) {
if (s->tracks)
g_array_free(s->tracks, TRUE);
g_free(s);
}
restorestate_clean:
if (jp)
g_object_unref(jp);
if (jr)
g_object_unref(jr);
}
static void put_playlist_patch(sp_playlist *playlist,
struct evhttp_request *request,
void *userdata) {
struct state *state = userdata;
struct evbuffer *buf = evhttp_request_get_input_buffer(request);
size_t buflen = evbuffer_get_length(buf);
if (buflen == 0) {
send_error(request, HTTP_BADREQUEST, "No body");
return;
}
// Read request body
json_error_t loads_error;
json_t *json = read_request_body_json(request, &loads_error);
if (json == NULL) {
send_error(request, HTTP_BADREQUEST,
loads_error.text ? loads_error.text : "Unable to parse JSON");
return;
}
if (!json_is_array(json)) {
json_decref(json);
send_error(request, HTTP_BADREQUEST, "Not valid JSON array");
return;
}
// Handle empty array
int num_tracks = json_array_size(json);
if (num_tracks == 0) {
send_reply(request, HTTP_OK, "OK", NULL);
return;
}
sp_track **tracks = calloc(num_tracks, sizeof (sp_track *));
int num_valid_tracks = 0;
for (int i = 0; i < num_tracks; i++) {
json_t *item = json_array_get(json, i);
if (!json_is_string(item)) {
json_decref(item);
continue;
}
char *uri = strdup(json_string_value(item));
sp_link *track_link = sp_link_create_from_string(uri);
free(uri);
if (track_link == NULL)
continue;
if (sp_link_type(track_link) != SP_LINKTYPE_TRACK) {
sp_link_release(track_link);
continue;
}
sp_track *track = sp_link_as_track(track_link);
if (track == NULL)
continue;
tracks[num_valid_tracks++] = track;
}
json_decref(json);
// Bail if no tracks could be read from input
if (num_valid_tracks == 0) {
send_error(request, HTTP_BADREQUEST, "No valid tracks");
free(tracks);
return;
}
tracks = realloc(tracks, num_valid_tracks * sizeof (sp_track *));
// Apply diff
apr_pool_t *pool = state->pool;
svn_diff_t *diff;
svn_error_t *diff_error = diff_playlist_tracks(&diff, playlist, tracks,
num_valid_tracks, pool);
if (diff_error != SVN_NO_ERROR) {
free(tracks);
svn_handle_error2(diff_error, stderr, false, "Diff");
send_error(request, HTTP_BADREQUEST, "Search failed");
return;
}
svn_error_t *apply_error = diff_playlist_tracks_apply(diff, playlist, tracks,
num_valid_tracks,
state->session);
if (apply_error != SVN_NO_ERROR) {
free(tracks);
svn_handle_error2(apply_error, stderr, false, "Updating playlist");
send_error(request, HTTP_BADREQUEST, "Could not apply diff");
return;
}
if (!sp_playlist_has_pending_changes(playlist)) {
free(tracks);
get_playlist(playlist, request, NULL);
return;
}
free(tracks);
register_playlist_callbacks(playlist, request, &get_playlist,
&playlist_update_in_progress_callbacks, NULL);
}
JNIEXPORT int JNICALL Java_jahspotify_impl_JahSpotifyImpl_playTrack (JNIEnv *env, jobject obj, jstring uri)
{
uint8_t *nativeURI = NULL;
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Initiating play\n");
nativeURI = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, uri, NULL );
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: uri: %s\n", nativeURI);
if (!g_audio_initialized)
{
audio_init(&g_audiofifo);
g_audio_initialized = JNI_TRUE;
}
// For each track, read out the info and populate all of the info in the Track instance
sp_link *link = sp_link_create_from_string(nativeURI);
if (link)
{
sp_track *t = sp_link_as_track(link);
if (!t)
{
fprintf(stderr,"No track from link\n");
return;
}
while (!sp_track_is_available(g_sess,t))
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Waiting for track ...\n");
sleep(1);
}
if (sp_track_error(t) != SP_ERROR_OK)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Error with track: %s\n",sp_error_message(sp_track_error(t)));
return;
}
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: name: %s duration: %d\n",sp_track_name(t),sp_track_duration(t));
if (g_currenttrack == t)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Same track!\n");
return;
}
// If there is one playing, unload that now
if (g_currenttrack && t != g_currenttrack)
{
// audio_fifo_flush(&g_audiofifo);
// Unload the current track now
sp_session_player_unload(g_sess);
sp_link *currentTrackLink = sp_link_create_from_track(g_currenttrack,0);
char *currentTrackLinkStr = NULL;
if (currentTrackLink)
{
currentTrackLinkStr = malloc ( sizeof ( char ) * ( 100 ) );
sp_link_as_string(currentTrackLink,currentTrackLinkStr,100);
sp_link_release(currentTrackLink);
}
signalTrackEnded(currentTrackLinkStr, JNI_TRUE);
if (currentTrackLinkStr)
{
free(currentTrackLinkStr);
}
sp_track_release(g_currenttrack);
g_currenttrack = NULL;
}
else
{
// audio_fifo_flush(&g_audiofifo);
// audio_close();
// audio_init(&g_audiofifo);
}
sp_track_add_ref(t);
sp_error result = sp_session_player_load(g_sess, t);
if (sp_track_error(t) != SP_ERROR_OK)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Issue loading track: %s\n", sp_error_message((sp_track_error(t))));
}
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Track loaded: %s\n", (result == SP_ERROR_OK ? "yes" : "no"));
// Update the global reference
g_currenttrack = t;
// Start playing the next track
sp_session_player_play(g_sess, 1);
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Playing track\n");
sp_link_release(link);
signalTrackStarted(nativeURI);
return 0;
}
else
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Unable to load link at this point\n");
}
return 1;
}
