static gboolean
start_next (RBTrackTransferBatch *batch)
{
GstEncodingProfile *profile = NULL;
if (batch->priv->cancelled == TRUE) {
return FALSE;
}
if (batch->priv->entries == NULL) {
/* guess we must be done.. */
g_signal_emit (batch, signals[COMPLETE], 0);
g_object_notify (G_OBJECT (batch), "task-outcome");
return FALSE;
}
batch->priv->current_fraction = 0.0;
rb_debug ("%d entries remain in the batch", g_list_length (batch->priv->entries));
while ((batch->priv->entries != NULL) && (batch->priv->cancelled == FALSE)) {
RhythmDBEntry *entry;
guint64 filesize;
gulong duration;
double fraction;
GList *n;
char *media_type;
char *extension;
n = batch->priv->entries;
batch->priv->entries = g_list_remove_link (batch->priv->entries, n);
entry = (RhythmDBEntry *)n->data;
g_list_free_1 (n);
rb_debug ("attempting to transfer %s", rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
/* calculate the fraction of the transfer that this entry represents */
filesize = rhythmdb_entry_get_uint64 (entry, RHYTHMDB_PROP_FILE_SIZE);
duration = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DURATION);
if (batch->priv->total_duration > 0) {
g_assert (duration > 0); /* otherwise total_duration would be 0 */
fraction = ((double)duration) / (double) batch->priv->total_duration;
} else if (batch->priv->total_size > 0) {
g_assert (filesize > 0); /* otherwise total_size would be 0 */
fraction = ((double)filesize) / (double) batch->priv->total_size;
} else {
int count = g_list_length (batch->priv->entries) +
g_list_length (batch->priv->done_entries) + 1;
fraction = 1.0 / ((double)count);
}
profile = NULL;
if (select_profile_for_entry (batch, entry, &profile, FALSE) == FALSE) {
rb_debug ("skipping entry %s, can't find an encoding profile",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
batch->priv->total_fraction += fraction;
continue;
}
if (profile != NULL) {
media_type = rb_gst_encoding_profile_get_media_type (profile);
extension = g_strdup (rb_gst_media_type_to_extension (media_type));
rb_gst_encoding_profile_set_preset (profile, NULL);
if (batch->priv->settings != NULL) {
GVariant *preset_settings;
char *active_preset;
preset_settings = g_settings_get_value (batch->priv->settings,
"media-type-presets");
active_preset = NULL;
g_variant_lookup (preset_settings, media_type, "s", &active_preset);
rb_debug ("setting preset %s for media type %s",
active_preset, media_type);
rb_gst_encoding_profile_set_preset (profile, active_preset);
g_free (active_preset);
}
} else {
media_type = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_MEDIA_TYPE);
extension = g_strdup (rb_gst_media_type_to_extension (media_type));
if (extension == NULL) {
extension = get_extension_from_location (entry);
}
}
g_free (batch->priv->current_dest_uri);
batch->priv->current_dest_uri = NULL;
g_signal_emit (batch, signals[GET_DEST_URI], 0,
entry,
media_type,
extension,
&batch->priv->current_dest_uri);
g_free (media_type);
g_free (extension);
if (batch->priv->current_dest_uri == NULL) {
rb_debug ("unable to build destination URI for %s, skipping",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
batch->priv->total_fraction += fraction;
continue;
}
batch->priv->current = entry;
batch->priv->current_entry_fraction = fraction;
batch->priv->current_profile = profile;
break;
}
if (batch->priv->current != NULL) {
g_signal_emit (batch, signals[TRACK_STARTED], 0,
batch->priv->current,
batch->priv->current_dest_uri);
start_encoding (batch, FALSE);
g_object_notify (G_OBJECT (batch), "task-detail");
}
return TRUE;
}
static gboolean
start_next (RBTrackTransferBatch *batch)
{
char *media_type = NULL;
char *extension = NULL;
if (batch->priv->cancelled == TRUE) {
return FALSE;
}
if (batch->priv->entries == NULL) {
/* guess we must be done.. */
g_signal_emit (batch, signals[COMPLETE], 0);
return FALSE;
}
batch->priv->current_fraction = 0.0;
batch->priv->current_encoder = rb_encoder_new ();
g_signal_connect_object (batch->priv->current_encoder, "progress",
G_CALLBACK (encoder_progress_cb),
batch, 0);
g_signal_connect_object (batch->priv->current_encoder, "overwrite",
G_CALLBACK (encoder_overwrite_cb),
batch, 0);
g_signal_connect_object (batch->priv->current_encoder, "completed",
G_CALLBACK (encoder_completed_cb),
batch, 0);
rb_debug ("%d entries remain in the batch", g_list_length (batch->priv->entries));
while ((batch->priv->entries != NULL) && (batch->priv->cancelled == FALSE)) {
RhythmDBEntry *entry;
guint64 filesize;
gulong duration;
double fraction;
GList *n;
n = batch->priv->entries;
batch->priv->entries = g_list_remove_link (batch->priv->entries, n);
entry = (RhythmDBEntry *)n->data;
g_list_free_1 (n);
rb_debug ("attempting to transfer %s", rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
/* calculate the fraction of the transfer that this entry represents */
filesize = rhythmdb_entry_get_uint64 (entry, RHYTHMDB_PROP_FILE_SIZE);
duration = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DURATION);
if (batch->priv->total_duration > 0) {
g_assert (duration > 0); /* otherwise total_duration would be 0 */
fraction = ((double)duration) / (double) batch->priv->total_duration;
} else if (batch->priv->total_size > 0) {
g_assert (filesize > 0); /* otherwise total_size would be 0 */
fraction = ((double)filesize) / (double) batch->priv->total_size;
} else {
int count = g_list_length (batch->priv->entries) +
g_list_length (batch->priv->done_entries) + 1;
fraction = 1.0 / ((double)count);
}
g_free (media_type);
g_free (extension);
media_type = NULL;
extension = NULL;
if (rb_encoder_get_media_type (batch->priv->current_encoder,
entry,
batch->priv->media_types,
&media_type,
&extension) == FALSE) {
rb_debug ("skipping entry %s, can't find a destination format",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
batch->priv->total_fraction += fraction;
continue;
}
g_free (batch->priv->current_dest_uri);
batch->priv->current_dest_uri = NULL;
g_signal_emit (batch, signals[GET_DEST_URI], 0,
entry,
media_type,
extension,
&batch->priv->current_dest_uri);
if (batch->priv->current_dest_uri == NULL) {
rb_debug ("unable to build destination URI for %s, skipping",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
batch->priv->total_fraction += fraction;
continue;
}
batch->priv->current = entry;
batch->priv->current_entry_fraction = fraction;
break;
}
if (batch->priv->current == NULL) {
g_object_unref (batch->priv->current_encoder);
batch->priv->current_encoder = NULL;
} else {
g_signal_emit (batch, signals[TRACK_STARTED], 0,
batch->priv->current,
batch->priv->current_dest_uri);
rb_encoder_encode (batch->priv->current_encoder,
batch->priv->current,
batch->priv->current_dest_uri,
media_type);
}
g_free (media_type);
g_free (extension);
return TRUE;
}
/**
* _rb_track_transfer_batch_start:
* @batch: a #RBTrackTransferBatch
* @queue: the #RBTrackTransferQueue
*
* Starts the batch transfer. Only to be called by the #RBTrackTransferQueue.
*/
void
_rb_track_transfer_batch_start (RBTrackTransferBatch *batch, GObject *queue)
{
gboolean total_duration_valid;
gboolean total_size_valid;
gboolean origin_valid;
guint64 filesize;
gulong duration;
RBSource *origin = NULL;
RBShell *shell;
GList *l;
g_object_get (queue, "shell", &shell, NULL);
/* calculate total duration and file size and figure out the
* origin source if we weren't given one to start with.
*/
total_duration_valid = TRUE;
total_size_valid = TRUE;
origin_valid = TRUE;
for (l = batch->priv->entries; l != NULL; l = l->next) {
RhythmDBEntry *entry = (RhythmDBEntry *)l->data;
filesize = rhythmdb_entry_get_uint64 (entry, RHYTHMDB_PROP_FILE_SIZE);
if (total_size_valid && filesize > 0) {
batch->priv->total_size += filesize;
} else {
total_size_valid = FALSE;
batch->priv->total_size = 0;
}
duration = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DURATION);
if (total_duration_valid && duration > 0) {
batch->priv->total_duration += duration;
} else {
total_duration_valid = FALSE;
batch->priv->total_duration = 0;
}
if (batch->priv->source == NULL) {
RhythmDBEntryType *entry_type;
RBSource *entry_origin;
entry_type = rhythmdb_entry_get_entry_type (entry);
entry_origin = rb_shell_get_source_by_entry_type (shell, entry_type);
if (origin == NULL && origin_valid == TRUE) {
origin = entry_origin;
} else if (origin != entry_origin) {
origin = NULL;
origin_valid = FALSE;
}
}
}
g_object_unref (shell);
if (origin != NULL) {
batch->priv->source = origin;
}
batch->priv->queue = RB_TRACK_TRANSFER_QUEUE (queue);
batch->priv->cancelled = FALSE;
batch->priv->total_fraction = 0.0;
g_signal_emit (batch, signals[STARTED], 0);
g_object_notify (G_OBJECT (batch), "task-progress");
g_object_notify (G_OBJECT (batch), "task-detail");
start_next (batch);
}
RBDAAPRecord *
rb_daap_record_new (RhythmDBEntry *entry)
{
RBDAAPRecord *record = NULL;
record = RB_DAAP_RECORD (g_object_new (RB_TYPE_DAAP_RECORD, NULL));
/* When browsing, entry will be NULL because we will pull
* the metadata from the DAAP query. When sharing, entry will
* point to an existing entry from the Rhythmbox DB.
*/
if (entry) {
gchar *ext;
record->priv->filesize = rhythmdb_entry_get_uint64
(entry, RHYTHMDB_PROP_FILE_SIZE);
record->priv->location = rhythmdb_entry_dup_string
(entry, RHYTHMDB_PROP_LOCATION);
record->priv->title = rhythmdb_entry_dup_string
(entry, RHYTHMDB_PROP_TITLE);
record->priv->artist = rhythmdb_entry_dup_string
(entry, RHYTHMDB_PROP_ARTIST);
record->priv->album = rhythmdb_entry_dup_string
(entry, RHYTHMDB_PROP_ALBUM);
/* Since we don't support album id's on Rhythmbox, "emulate" it */
record->priv->albumid = (gintptr) rhythmdb_entry_get_refstring
(entry, RHYTHMDB_PROP_ALBUM);
record->priv->genre = rhythmdb_entry_dup_string
(entry, RHYTHMDB_PROP_GENRE);
/* FIXME: Support transcoding: */
/* FIXME: we should use RHYTHMDB_PROP_MIMETYPE instead */
ext = strrchr (record->priv->location, '.');
if (ext == NULL) {
ext = "mp3";
} else {
ext++;
}
record->priv->mediakind = DMAP_MEDIA_KIND_MUSIC;
record->priv->real_format = g_strdup (ext);
record->priv->format = g_strdup (record->priv->real_format);
/* Only support songs */
record->priv->mediakind = 1;
record->priv->track = rhythmdb_entry_get_ulong
(entry, RHYTHMDB_PROP_TRACK_NUMBER);
record->priv->duration = rhythmdb_entry_get_ulong
(entry, RHYTHMDB_PROP_DURATION);
record->priv->rating = (gint) rhythmdb_entry_get_double
(entry, RHYTHMDB_PROP_RATING);
record->priv->year = rhythmdb_entry_get_ulong
(entry, RHYTHMDB_PROP_YEAR);
record->priv->firstseen = rhythmdb_entry_get_ulong
(entry, RHYTHMDB_PROP_FIRST_SEEN);
record->priv->mtime = rhythmdb_entry_get_ulong
(entry, RHYTHMDB_PROP_MTIME);
record->priv->disc = rhythmdb_entry_get_ulong
(entry, RHYTHMDB_PROP_DISC_NUMBER);
record->priv->bitrate = rhythmdb_entry_get_ulong
(entry, RHYTHMDB_PROP_BITRATE);
}
return record;
}
