Spotify::Error Spotify::Session::seek( int pos ) { Spotify::Error error = sp_session_player_seek( m_session, pos ); if( !error.isError() ) m_trackPos = pos; return error; }
static int try_play(sp_session *session, sp_track *t,int offset) { sp_error err; fprintf(stderr,"try play\n"); err = sp_session_player_load(session,t); if( err != SP_ERROR_OK) { fprintf(stderr,"Load failed %d\n",err); } if(!sp_track_is_loaded(t)) { if(g_track_to_be_played != t) { if(g_track_to_be_played) sp_track_release(g_track_to_be_played); g_track_to_be_played = t; //FIXME: Do I need to addref? sp_track_add_ref(g_track_to_be_played); } } else { //FIXME: Seek! // g_current_fifo_idx = (g_current_fifo_idx+1) % 2; sp_session_player_seek(session,offset); sp_session_player_play(session,true); sp_album *album = sp_track_album(t); if(album) { const byte *id = sp_album_cover(album); g_gazify.current_t = t; if(id) { sp_image *img = sp_image_create(session,id); sp_image_add_load_callback(img,&image_loaded,&g_gazify); } } g_track_to_be_played = NULL; } return err; }
void session_seek(guint pos) { sp_session_player_seek(g_session, pos); g_audio_time = pos; g_audio_samples = 0; cb_notify_main_thread(NULL); }
static PyObject *Session_seek(Session *self, PyObject *args) { int seek; sp_error err; if(!PyArg_ParseTuple(args, "i", &seek)) return NULL; Py_BEGIN_ALLOW_THREADS err = sp_session_player_seek(self->_session, seek); Py_END_ALLOW_THREADS return handle_error(err); }
void seek(list<int> int_params, list<string> string_params, sp_session *session, sp_track *track) { int pos_ms = int_params.front(); if (s_is_playing) sp_session_player_play(session, false); sp_session_player_seek(session, pos_ms); if (s_is_playing) sp_session_player_play(session, true); s_player_position = pos_ms; }
void seek(list<int> int_params, list<string> string_params, sp_session *session, sp_track *track) { float position = (float)int_params.front() / 100.0; int pos_ms = (int) ((float) sp_track_duration(track) * position); if (s_is_playing) sp_session_player_play(session, false); sp_session_player_seek(session, pos_ms); if (s_is_playing) sp_session_player_play(session, true); s_player_position = pos_ms / 1000; }
static PyObject * Session_seek(Session * self, PyObject *args) { int seek; if (!PyArg_ParseTuple(args, "i", &seek)) return NULL; Py_BEGIN_ALLOW_THREADS; sp_session_player_seek(self->_session, seek); Py_END_ALLOW_THREADS; Py_RETURN_NONE; }
void QSpotifySession::seek(int offset) { qDebug () << "QSpotifySession::seek"; if (!m_currentTrack) return; sp_session_player_seek(m_sp_session, offset); m_currentTrackPosition = offset; m_previousTrackRemaining = 0; emit currentTrackPositionChanged(); QCoreApplication::postEvent(g_audioWorker, new QEvent(QEvent::Type(ResetBufferEventType))); }
static PyObject * Session_seek(PyObject *self, PyObject *args) { int seek; sp_error error; if (!PyArg_ParseTuple(args, "i", &seek)) return NULL; Py_BEGIN_ALLOW_THREADS; error = sp_session_player_seek(Session_SP_SESSION(self), seek); Py_END_ALLOW_THREADS; return none_or_raise_error(error); }
// ---------------------------------------------------------------------------- // void SpotifyEngine::_startTrack( ) { if ( m_track_queue.size() ) { CSingleLock lock( &m_mutex, TRUE ); TrackQueueEntry entry = m_track_queue.front(); m_track_queue.pop_front(); m_current_track = entry.m_track; m_track_played_queue.push_back( entry ); sp_error result = sp_session_player_load( m_spotify_session, m_current_track ); if ( result != SP_ERROR_OK ) { log( "Error %d from sp_session_player_load", (INT)result ); } m_track_state = TRACK_STREAM_PENDING; m_track_length_ms = sp_track_duration( m_current_track ); m_track_seek_ms = entry.m_seek_ms > m_track_length_ms ? 0 : entry.m_seek_ms; getTrackLink( m_current_track, m_current_track_link ); if ( m_track_seek_ms != 0L ) sp_session_player_seek( m_spotify_session, m_track_seek_ms ); else if ( !haveTrackAnalysis(m_current_track_link) ) { m_analyzer = new TrackAnalyzer( &m_waveFormat, m_track_length_ms, m_current_track_link ); } if ( !isTrackPaused() ) { result = sp_session_player_play( m_spotify_session, true ); if ( result != SP_ERROR_OK ) { log( "Error %d from sp_session_player_play", (INT)result ); } } sendTrackQueueEvent(); } }
__int64 Codec::Seek(__int64 iSeekTime) { Logger::printOut("trying to seek"); sp_session_player_seek(getSession(), iSeekTime); m_bufferPos = 0; return iSeekTime; }
void SpotWorker::seekPlayer(int offset) { sp_session_player_seek(currentSession, offset); }
void Session::Seek( int offset ) { sp_session_player_seek( m_pSession, offset ); }
/* 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; }