static void write_album_to_device (RBMtpThread *thread, LIBMTP_album_t *album, gboolean new_album) { if (new_album) { if (LIBMTP_Create_New_Album (thread->device, album) != 0) { LIBMTP_destroy_album_t (album); rb_debug ("LIBMTP_Create_New_Album failed.."); rb_mtp_thread_report_errors (thread, FALSE); } } else { if (LIBMTP_Update_Album (thread->device, album) != 0) { rb_debug ("LIBMTP_Update_Album failed.."); rb_mtp_thread_report_errors (thread, FALSE); } } }
static void add_track_to_album (RBMtpSource *source, const char *album_name, LIBMTP_track_t *track) { RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source); LIBMTP_album_t *album; album = g_hash_table_lookup (priv->album_map, album_name); if (album != NULL) { /* add track to album */ album->tracks = realloc (album->tracks, sizeof(uint32_t) * (album->no_tracks+1)); album->tracks[album->no_tracks] = track->item_id; album->no_tracks++; rb_debug ("adding track ID %d to album ID %d; now %d tracks", track->item_id, album->album_id, album->no_tracks); if (LIBMTP_Update_Album (priv->device, album) != 0) { rb_debug ("LIBMTP_Update_Album failed.."); report_libmtp_errors (priv->device, FALSE); } } else { /* add new album */ album = LIBMTP_new_album_t (); album->name = strdup (album_name); album->no_tracks = 1; album->tracks = malloc (sizeof(uint32_t)); album->tracks[0] = track->item_id; album->storage_id = track->storage_id; /* fill in artist and genre? */ rb_debug ("creating new album (%s) for track ID %d", album->name, track->item_id); if (LIBMTP_Create_New_Album (priv->device, album) != 0) { LIBMTP_destroy_album_t (album); rb_debug ("LIBMTP_Create_New_Album failed.."); report_libmtp_errors (priv->device, FALSE); } else { g_hash_table_insert (priv->album_map, album->name, album); } } }
static void remove_track_from_album (RBMtpSource *source, const char *album_name, LIBMTP_track_t *track) { RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source); LIBMTP_album_t *album; int i; album = g_hash_table_lookup (priv->album_map, album_name); if (album == NULL) { rb_debug ("Couldn't find an album for %s", album_name); return; } for (i = 0; i < album->no_tracks; i++) { if (album->tracks[i] == track->item_id) { break; } } if (i == album->no_tracks) { rb_debug ("Couldn't find track %d in album %d", track->item_id, album->album_id); return; } memmove (album->tracks + i, album->tracks + i + 1, album->no_tracks - (i+1)); album->no_tracks--; if (album->no_tracks == 0) { rb_debug ("deleting empty album %d", album->album_id); if (LIBMTP_Delete_Object (priv->device, album->album_id) != 0) { report_libmtp_errors (priv->device, FALSE); } g_hash_table_remove (priv->album_map, album_name); } else { rb_debug ("updating album %d: %d tracks remaining", album->album_id, album->no_tracks); if (LIBMTP_Update_Album (priv->device, album) != 0) { report_libmtp_errors (priv->device, FALSE); } } }
static void remove_track_from_album (RBMtpThread *thread, RBMtpThreadTask *task) { LIBMTP_album_t *album; int i; album = g_hash_table_lookup (thread->albums, task->album); if (album == NULL) { rb_debug ("Couldn't find an album for %s", task->album); return; } for (i = 0; i < album->no_tracks; i++) { if (album->tracks[i] == task->track_id) { break; } } if (i == album->no_tracks) { rb_debug ("Couldn't find track %d in album %d", task->track_id, album->album_id); return; } memmove (album->tracks + i, album->tracks + i + 1, album->no_tracks - (i+1)); album->no_tracks--; if (album->no_tracks == 0) { rb_debug ("deleting empty album %d", album->album_id); if (LIBMTP_Delete_Object (thread->device, album->album_id) != 0) { rb_mtp_thread_report_errors (thread, FALSE); } g_hash_table_remove (thread->albums, task->album); } else { rb_debug ("updating album %d: %d tracks remaining", album->album_id, album->no_tracks); if (LIBMTP_Update_Album (thread->device, album) != 0) { rb_mtp_thread_report_errors (thread, FALSE); } } }
static int add_track_to_album(LIBMTP_album_t *albuminfo, LIBMTP_track_t *trackmeta) { LIBMTP_album_t *album; LIBMTP_album_t *album_orig; LIBMTP_album_t *found_album = NULL; int ret; /* Look for the album */ album = LIBMTP_Get_Album_List(device); album_orig = album; while(album != NULL) { if ((album->name != NULL && album->artist != NULL && !strcmp(album->name, albuminfo->name) && !strcmp(album->artist, albuminfo->artist)) || (album->name != NULL && album->composer != NULL && !strcmp(album->name, albuminfo->name) && !strcmp(album->composer, albuminfo->composer))) { /* Disconnect this album for later use */ found_album = album; album = album->next; found_album->next = NULL; } else { album = album->next; } } if (found_album == NULL) { printf("Could not find Album. Retrying with only Album name\n"); album = album_orig; while(album != NULL) { if ((album->name != NULL) && !strcmp(album->name, albuminfo->name) ){ /* Disconnect this album for later use */ found_album = album; album = album->next; found_album->next = NULL; } else { album = album->next; } } } if (found_album != NULL) { uint32_t *tracks; tracks = (uint32_t *)malloc((found_album->no_tracks+1) * sizeof(uint32_t)); printf("Album \"%s\" found: updating...\n", found_album->name); if (!tracks) { printf("failed malloc in add_track_to_album()\n"); return 1; } found_album->no_tracks++; if (found_album->tracks != NULL) { memcpy(tracks, found_album->tracks, found_album->no_tracks * sizeof(uint32_t)); free(found_album->tracks); } tracks[found_album->no_tracks-1] = trackmeta->item_id; found_album->tracks = tracks; ret = LIBMTP_Update_Album(device, found_album); } else { uint32_t *trackid; trackid = (uint32_t *)malloc(sizeof(uint32_t)); *trackid = trackmeta->item_id; albuminfo->tracks = trackid; albuminfo->no_tracks = 1; albuminfo->storage_id = trackmeta->storage_id; printf("Album doesn't exist: creating...\n"); ret = LIBMTP_Create_New_Album(device, albuminfo); /* albuminfo will be destroyed later by caller */ } /* Delete the earlier retrieved Album list */ album=album_orig; while(album!=NULL){ LIBMTP_album_t *tmp; tmp = album; album = album->next; LIBMTP_destroy_album_t(tmp); } if (ret != 0) { printf("Error creating or updating album.\n"); printf("(This could be due to that your device does not support albums.)\n"); LIBMTP_Dump_Errorstack(device); LIBMTP_Clear_Errorstack(device); } else { printf("success!\n"); } return ret; }
void Plugin::AppendAlbum (LIBMTP_mtpdevice_t *device, LIBMTP_track_t *track, const UnmountableFileInfo& info) { auto albuminfo = LIBMTP_new_album_t (); albuminfo->artist = strdup (info.Artist_.toUtf8 ().constData ()); albuminfo->name = strdup (info.Album_.toUtf8 ().constData ()); albuminfo->genre = strdup (info.Genres_.join ("; ").toUtf8 ().constData ()); auto album = LIBMTP_Get_Album_List (device); auto albumOrig = album; decltype (album) foundAlbum = nullptr, resultingAlgum = nullptr; while (album) { if (album->name && (album->artist || album->composer) && QString::fromUtf8 (album->name) == info.Album_ && (QString::fromUtf8 (album->artist) == info.Artist_ || QString::fromUtf8 (album->composer) == info.Artist_)) { foundAlbum = album; album = album->next; foundAlbum->next = nullptr; } else album = album->next; } if (foundAlbum) { auto tracks = static_cast<uint32_t*> (malloc ((foundAlbum->no_tracks + 1) * sizeof (uint32_t))); ++foundAlbum->no_tracks; if (foundAlbum->tracks) { memcpy (tracks, foundAlbum->tracks, foundAlbum->no_tracks * sizeof (uint32_t)); free (foundAlbum->tracks); } tracks [foundAlbum->no_tracks - 1] = track->item_id; foundAlbum->tracks = tracks; if (LIBMTP_Update_Album (device, foundAlbum)) { LIBMTP_Dump_Errorstack (device); LIBMTP_Clear_Errorstack (device); } resultingAlgum = foundAlbum; } else { auto trackId = static_cast<uint32_t*> (malloc (sizeof (uint32_t))); *trackId = track->item_id; albuminfo->tracks = trackId; albuminfo->no_tracks = 1; albuminfo->storage_id = track->storage_id; if (LIBMTP_Create_New_Album (device, albuminfo)) { LIBMTP_Dump_Errorstack (device); LIBMTP_Clear_Errorstack (device); } resultingAlgum = albuminfo; } SetAlbumArt (device, resultingAlgum, info.AlbumArtPath_); while (albumOrig) { auto tmp = albumOrig; albumOrig = albumOrig->next; LIBMTP_destroy_album_t (tmp); } LIBMTP_destroy_album_t (albuminfo); }