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;
}
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;
}
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;
}
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;
}
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);
}
//----------------------------------------------
// 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;
}
JNIEXPORT jobject JNICALL Java_jahspotify_impl_JahSpotifyImpl_retrievePlaylist ( JNIEnv *env, jobject obj, jstring uri)
{
jobject playlistInstance;
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_retrievePlaylist: Could not create link!\n" );
return JNI_FALSE;
}
sp_playlist *playlist = sp_playlist_create(g_sess,link);
while (!sp_playlist_is_loaded(playlist))
{
fprintf ( stderr, "jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrievePlaylist: Waiting for playlist to be loaded ...\n" );
sleep(1);
}
playlistInstance = createJPlaylist(env, playlist);
if (playlist)
sp_playlist_release(playlist);
if (link)
sp_link_release(link);
if (nativeUri)
free(nativeUri);
return playlistInstance;
}
JNIEXPORT jobject JNICALL Java_jahspotify_impl_JahSpotifyImpl_retrieveAlbum ( JNIEnv *env, jobject obj, jstring uri)
{
jobject albumInstance;
uint8_t *nativeUri = NULL;
nativeUri = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, uri, NULL );
sp_link *link = sp_link_create_from_string(nativeUri);
if (link)
{
sp_album *album= sp_link_as_album(link);
if (album)
{
sp_album_add_ref(album);
albumInstance = createJAlbumInstance(env, album);
sp_album_release(album);
}
sp_link_release(link);
}
if (nativeUri)
(*env)->ReleaseStringUTFChars(env, uri,nativeUri);
return albumInstance;
}
/**
* 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) */
}
PHP_METHOD(Spotify, getArtistByURI)
{
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_ARTIST != sp_link_type(link)) {
RETURN_FALSE;
}
sp_artist *artist = sp_link_as_artist(link);
object_init_ex(return_value, spotifyartist_ce);
SPOTIFY_METHOD2(SpotifyArtist, __construct, &temp, return_value, object, artist);
sp_link_release(link);
}
PHP_METHOD(Spotify, getAlbumByURI)
{
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_ALBUM != sp_link_type(link)) {
RETURN_FALSE;
}
sp_album *album = sp_link_as_album(link);
while (!sp_album_is_loaded(album)) {
sp_session_process_events(p->session, &timeout);
}
object_init_ex(return_value, spotifyalbum_ce);
SPOTIFY_METHOD2(SpotifyAlbum, __construct, &temp, return_value, object, album);
sp_link_release(link);
}
void upvoteHelper(const char* s)
{
// turns s into sp_link
sp_link* temp = sp_link_create_from_string(s);
upvote(temp);
// calls upvote
}
sp_link *
sp_link_create_from_search(sp_search *search)
{
char *uri_encoded = url_encode(search->query);
char *uri = ALLOC_STR(strlen("spotify:search:") + strlen(uri_encoded));
sprintf(uri, "spotify:search:%s", uri_encoded);
return sp_link_create_from_string(uri);
}
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;
}
void start_playlist(char *uri)
{
printf("Start playlist: %s\n", uri);
sp_link *link = sp_link_create_from_string(uri);
sp_playlist *pl = sp_playlist_create(g_sess, link);
sp_playlist_add_callbacks(pl, &pl_callbacks, NULL);
sprintf(g_last_playlist_name, sp_playlist_name(pl));
// hardware_banner(sp_playlist_name(pl), 200);
g_jukeboxlist = pl;
try_jukebox_start();
}
static void get_album_tracks(){
sp_link * new_link;
new_link = sp_link_create_from_string(g_guid);
sp_album * new_album;
new_album = sp_link_as_album(new_link);
sp_albumbrowse* albumbrowser;
albumbrowser = sp_albumbrowse_create(g_sess,new_album,albumbrowser_callback,NULL);
}
sp_link *
sp_link_create_from_artistbrowse_portrait(sp_artistbrowse *artistbrowse, int index)
{
const byte *image_id = sp_artistbrowse_portrait(artistbrowse, index);
if ( ! image_id)
{
return NULL;
}
return sp_link_create_from_string(image_id_to_uri(image_id));
}
sp_link *
sp_link_create_from_album_cover(sp_album *album, sp_image_size size)
{
const byte *image_id = sp_album_cover(album, size);
if ( ! image_id)
{
return NULL;
}
return sp_link_create_from_string(image_id_to_uri(image_id));
}
sp_link *
sp_link_create_from_artist_portrait(sp_artist *artist, sp_image_size size)
{
const byte *image_id = sp_artist_portrait(artist, size);
if ( ! image_id)
{
return NULL;
}
return sp_link_create_from_string(image_id_to_uri(image_id));
}
static void _spotify_play(sp_session *session, std::string uri)
{
assert(pthread_equal(pthread_self(),g_spotify_tid));
sp_link *l = sp_link_create_from_string(uri.c_str());
sp_error err;
int offset;
if(!l || sp_link_type(l) != SP_LINKTYPE_TRACK) {
return;
}
sp_track *t = sp_link_as_track_and_offset(l,&offset);
try_play(session,t,offset);
sp_link_release(l);
return;
}
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);
}
}
sp_link *
sp_link_create_from_track(sp_track *track, int offset)
{
const char *link = registry_reverse_find((void *) track);
int mins = 0, secs = 0;
char *link_with_offset = NULL;
if (offset > 0)
{
link_with_offset = ALLOC_STR(strlen(link) + strlen("#00:00"));
offset = offset / 1000;
mins = (offset / 60) % 60;
secs = (offset - mins * 60) % 60;
sprintf(link_with_offset, "%s", link);
sprintf(link_with_offset + strlen(link), "#%02d:%02d", mins, secs);
return sp_link_create_from_string(link_with_offset);
}
else
{
return sp_link_create_from_string(link);
}
}
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;
}
int luasp_link_create_from_string(lua_State *L) {
// link = spotify.link_create_from_string(uri)
if (lua_gettop(L) != 1 || !lua_isstring(L, 1))
{
lua_pushstring(L, "incorrect argument to link_create_from_string(...)");
lua_error(L);
}
sp_link* t_link = sp_link_create_from_string(lua_tostring(L, 1));
if (t_link)
lua_pushlightuserdata(L, t_link);
else
lua_pushnil(L);
return 1;
}
// 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 PyObject *
Link_from_string(Link * self, PyObject *args)
{
char *s, *s2;
PyObject *plink;
if (!PyArg_ParseTuple(args, "s", &s))
return NULL;
s2 = malloc(strlen(s) + 1);
strcpy(s2, s);
sp_link *link = sp_link_create_from_string(s2);
if (!link) {
PyErr_SetString(SpotifyError, "Failed to get link from a Spotify URI");
return NULL;
}
plink = Link_FromSpotify(link);
return plink;
}
void QSpotifySession::sendImageRequest(const QString &id)
{
qDebug() << "QSpotifySession::sendImageRequest" << id;
sp_image *image = nullptr;
byte *idPtr = QSpotifyPlaylist::getImageIdPtr(id);
if(idPtr)
image = sp_image_create(m_sp_session, idPtr);
else {
sp_link *link = sp_link_create_from_string(id.toUtf8().constData());
if(link) {
image = sp_image_create_from_link(m_sp_session, link);
sp_link_release(link);
}
}
if (image) {
g_imageRequestObject.insert(image, id);
sp_image_add_load_callback(image, callback_image_loaded, nullptr);
}
}
/**
* 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 *session, sp_error error)
{
sp_user *me;
const char *my_name;
if (SP_ERROR_OK != error) {
fprintf(stderr, "failed to log in to Spotify: %s\n",
sp_error_message(error));
sp_session_release(session);
exit(4);
}
// Let us print the nice message...
me = sp_session_user(session);
my_name = (sp_user_is_loaded(me) ? sp_user_display_name(me) : sp_user_canonical_name(me));
fprintf(stderr, "Logged in to Spotify as user %s\n", my_name);
sp_playlist *pl = sp_playlist_create(session, sp_link_create_from_string("spotify:user:devnevyn:playlist:44ZXlJstDZrwuQvWPOo7KX"));
empty_callbacks.playlist_state_changed = foo;
sp_playlist_add_callbacks(pl, &empty_callbacks, NULL);
}