static void
rb_media_player_source_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (object);
switch (prop_id) {
case PROP_ENCODING_TARGET:
if (priv->encoding_target) {
gst_encoding_target_unref (priv->encoding_target);
}
priv->encoding_target = GST_ENCODING_TARGET (g_value_dup_object (value));
break;
case PROP_ENCODING_SETTINGS:
if (priv->encoding_settings) {
g_object_unref (priv->encoding_settings);
}
priv->encoding_settings = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
impl_dispose (GObject *object)
{
RBTrackTransferBatch *batch = RB_TRACK_TRANSFER_BATCH (object);
g_clear_object (&batch->priv->source);
g_clear_object (&batch->priv->destination);
g_clear_object (&batch->priv->settings);
if (batch->priv->target != NULL) {
gst_encoding_target_unref (batch->priv->target);
batch->priv->target = NULL;
}
G_OBJECT_CLASS (rb_track_transfer_batch_parent_class)->dispose (object);
}
/**
* rb_transfer_target_get_format_descriptions:
* @target: an #RBTransferTarget
*
* Returns a #GList of allocated media format descriptions for
* the formats supported by the target. The list and the strings
* it holds must be freed by the caller.
*
* Return value: (element-type utf8) (transfer full): list of descriptions.
*/
GList *
rb_transfer_target_get_format_descriptions (RBTransferTarget *target)
{
GstEncodingTarget *enctarget;
const GList *l;
GList *desc = NULL;
g_object_get (target, "encoding-target", &enctarget, NULL);
if (enctarget != NULL) {
for (l = gst_encoding_target_get_profiles (enctarget); l != NULL; l = l->next) {
GstEncodingProfile *profile = l->data;
desc = g_list_append (desc, g_strdup (gst_encoding_profile_get_description (profile)));
}
gst_encoding_target_unref (enctarget);
}
return desc;
}
static GList *
merge_targets (GList * res, GList * extra)
{
GList *tmp;
/* FIXME : We should merge the system-wide profiles into the user-locals
* instead of stopping at identical target names */
for (tmp = extra; tmp; tmp = tmp->next) {
GstEncodingTarget *target = (GstEncodingTarget *) tmp->data;
if (g_list_find_custom (res, target, (GCompareFunc) compare_targets))
gst_encoding_target_unref (target);
else
res = g_list_append (res, target);
}
g_list_free (extra);
return res;
}
/**
* gst_encoding_profile_find:
* @targetname: (transfer none): The name of the target
* @profilename: (transfer none): (allow-none): The name of the profile, if %NULL
* provided, it will default to the encoding profile called `default`.
* @category: (transfer none) (allow-none): The target category. Can be %NULL
*
* Find the #GstEncodingProfile with the specified name and category.
*
* Returns: (transfer full): The matching #GstEncodingProfile or %NULL.
*/
GstEncodingProfile *
gst_encoding_profile_find (const gchar * targetname, const gchar * profilename,
const gchar * category)
{
GstEncodingProfile *res = NULL;
GstEncodingTarget *target;
g_return_val_if_fail (targetname != NULL, NULL);
target = gst_encoding_target_load (targetname, category, NULL);
if (target) {
res =
gst_encoding_target_get_profile (target,
profilename ? profilename : "default");
gst_encoding_target_unref (target);
}
return res;
}
static void
rb_media_player_source_dispose (GObject *object)
{
RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (object);
if (priv->sync_settings) {
g_object_unref (priv->sync_settings);
priv->sync_settings = NULL;
}
if (priv->sync_state) {
g_object_unref (priv->sync_state);
priv->sync_state = NULL;
}
if (priv->encoding_target) {
gst_encoding_target_unref (priv->encoding_target);
priv->encoding_target = NULL;
}
G_OBJECT_CLASS (rb_media_player_source_parent_class)->dispose (object);
}
static void
start_next_batch (RBTrackTransferQueue *queue)
{
int count;
int total;
gboolean can_continue;
GtkWidget *dialog;
GtkWindow *window;
GList *profiles = NULL;
char *message;
if (queue->priv->current != NULL) {
return;
}
queue->priv->current = RB_TRACK_TRANSFER_BATCH (g_queue_pop_head (queue->priv->batch_queue));
g_object_notify (G_OBJECT (queue), "batch");
if (queue->priv->current == NULL) {
/* indicate to anyone watching that we're not doing anything */
g_signal_emit (queue, signals[TRANSFER_PROGRESS], 0, 0, 0, 0.0, 0);
return;
}
queue->priv->overwrite_decision = OVERWRITE_PROMPT;
g_object_get (queue->priv->current, "total-entries", &total, NULL);
count = 0;
can_continue = rb_track_transfer_batch_check_profiles (queue->priv->current,
&profiles,
&count);
if (can_continue && count == 0 && profiles == NULL) {
/* no problems, go ahead */
actually_start_batch (queue);
return;
}
if (profiles == NULL) {
const char *str;
str = ngettext ("%d file cannot be transferred as it must be converted into "
"a format supported by the target device but no suitable "
"encoding profiles are available",
"%d files cannot be transferred as they must be converted into "
"a format supported by the target device but no suitable "
"encoding profiles are available",
count);
message = g_strdup_printf (str, count);
} else {
GPtrArray *descriptions;
GstEncodingTarget *target;
char *plugins;
gboolean is_library;
descriptions = get_missing_plugin_strings (profiles, TRUE);
plugins = g_strjoinv ("\n", (char **)descriptions->pdata);
/* this is a tiny bit hackish */
g_object_get (queue->priv->current, "encoding-target", &target, NULL);
is_library = (g_strcmp0 (gst_encoding_target_get_name (target), "rhythmbox-library") == 0);
gst_encoding_target_unref (target);
if (is_library) {
/* XXX should provide the option of picking a different format? */
message = g_strdup_printf (_("Additional software is required to encode media "
"in your preferred format:\n%s"), plugins);
} else {
const char *str;
str = ngettext ("Additional software is required to convert %d file "
"into a format supported by the target device:\n%s",
"Additional software is required to convert %d files "
"into a format supported by the target device:\n%s",
count);
message = g_strdup_printf (str, count, plugins);
}
g_free (plugins);
g_ptr_array_free (descriptions, TRUE);
}
g_object_get (queue->priv->shell, "window", &window, NULL);
dialog = rb_alert_dialog_new (window,
0,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_NONE,
_("Unable to transfer tracks"),
message);
g_object_unref (window);
g_free (message);
gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Cancel the transfer"), GTK_RESPONSE_CANCEL);
if (can_continue) {
gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Skip these files"), GTK_RESPONSE_YES);
}
if (profiles != NULL && gst_install_plugins_supported ()) {
gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Install"), GTK_RESPONSE_ACCEPT);
}
rb_alert_dialog_set_details_label (RB_ALERT_DIALOG (dialog), NULL);
g_signal_connect_object (dialog, "response", G_CALLBACK (missing_encoder_response_cb), queue, 0);
gtk_widget_show (dialog);
if (profiles != NULL) {
g_list_free (profiles);
}
}
/**
* rb_transfer_target_transfer:
* @target: an #RBTransferTarget
* @entries: (element-type RB.RhythmDBEntry): a #GList of entries to transfer
* @defer: if %TRUE, don't start the transfer until
*
* Starts tranferring @entries to the target. This returns the
* #RBTrackTransferBatch that it starts, so the caller can track
* the progress of the transfer, or NULL if the target doesn't
* want any of the entries.
*
* Return value: (transfer full): an #RBTrackTransferBatch, or NULL
*/
RBTrackTransferBatch *
rb_transfer_target_transfer (RBTransferTarget *target, GList *entries, gboolean defer)
{
RBTrackTransferQueue *xferq;
RBTaskList *tasklist;
RBShell *shell;
GList *l;
RhythmDBEntryType *our_entry_type;
RBTrackTransferBatch *batch;
gboolean start_batch = FALSE;
g_object_get (target,
"shell", &shell,
"entry-type", &our_entry_type,
NULL);
g_object_get (shell,
"track-transfer-queue", &xferq,
"task-list", &tasklist,
NULL);
g_object_unref (shell);
batch = g_object_steal_data (G_OBJECT (target), "transfer-target-batch");
if (batch == NULL) {
batch = rb_track_transfer_batch_new (NULL, NULL, G_OBJECT (target));
g_signal_connect_object (batch, "get-dest-uri", G_CALLBACK (get_dest_uri_cb), target, 0);
g_signal_connect_object (batch, "track-done", G_CALLBACK (track_done_cb), target, 0);
} else {
start_batch = TRUE;
}
for (l = entries; l != NULL; l = l->next) {
RhythmDBEntry *entry;
RhythmDBEntryType *entry_type;
const char *location;
entry = (RhythmDBEntry *)l->data;
location = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION);
entry_type = rhythmdb_entry_get_entry_type (entry);
if (entry_type != our_entry_type) {
if (rb_transfer_target_should_transfer (target, entry)) {
rb_debug ("pasting entry %s", location);
rb_track_transfer_batch_add (batch, entry);
start_batch = TRUE;
} else {
rb_debug ("target doesn't want entry %s", location);
}
} else {
rb_debug ("can't copy entry %s from the target to itself", location);
}
}
g_object_unref (our_entry_type);
if (start_batch) {
if (defer) {
g_object_set_data_full (G_OBJECT (target), "transfer-target-batch", g_object_ref (batch), g_object_unref);
} else {
GstEncodingTarget *encoding_target;
char *name;
char *label;
g_object_get (target, "encoding-target", &encoding_target, NULL);
g_object_set (batch, "encoding-target", encoding_target, NULL);
gst_encoding_target_unref (encoding_target);
g_object_get (target, "name", &name, NULL);
label = g_strdup_printf (_("Transferring tracks to %s"), name);
g_object_set (batch, "task-label", label, NULL);
g_free (name);
g_free (label);
rb_task_list_add_task (tasklist, RB_TASK_PROGRESS (batch));
rb_track_transfer_queue_start_batch (xferq, batch);
}
} else {
g_object_unref (batch);
batch = NULL;
}
g_object_unref (xferq);
g_object_unref (tasklist);
return batch;
}
