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