← Back to branch summary

~and471/+junk/symphony-legacy

« back to all changes in this revision

Viewing changes to src/backend/gstreamer.c

  • Committer: rugby471 at gmail
  • Date: 2011-02-18 21:11:12 UTC
  • Revision ID: rugby471@gmail.com-20110218211112-w3dhag8ttp1quckk
lots more :)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/backend/gstreamer.c
52
52
 
53
53
typedef struct _Album Album;
54
54
typedef struct _AlbumClass AlbumClass;
55
 
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
56
55
 
57
56
struct _Player {
58
57
        GObject parent_instance;
77
76
struct _Track {
78
77
        GObject parent_instance;
79
78
        TrackPrivate * priv;
 
79
        guint id;
80
80
        gchar* title;
81
81
        gchar* artist;
82
82
        gchar* album;
128
128
void player_pause (Player* self);
129
129
void player_seek (Player* self, gint64 time);
130
130
GstState player_get_state (Player* self);
 
131
gchar* player_state_as_string (GstState state);
131
132
void player_toggle_play_pause (Player* self);
132
133
Track* player_get_current_track (Player* self);
133
134
void player_previous (Player* self);
137
138
void player_set_track_duration_int (Player* self, gint64 value);
138
139
void player_set_track_position_int (Player* self, gint64 value);
139
140
void player_set_track_position (Player* self, const gchar* value);
140
 
GHashTable* player_get_track_mpris_metadata (Player* self);
141
 
static void _g_free0_ (gpointer var);
142
 
static void _g_variant_unref0_ (gpointer var);
143
 
static GVariant* _variant_new1 (const gchar* value);
144
 
static GVariant* _variant_new2 (const gchar* value);
145
 
static GVariant* _variant_new3 (const gchar* value);
146
 
static GVariant* _variant_new4 (gint32 value);
147
141
const gchar* player_get_track_position (Player* self);
148
142
gint64 player_get_track_position_int (Player* self);
149
143
gint64 player_get_track_duration_int (Player* self);
310
304
}
311
305
 
312
306
 
 
307
gchar* player_state_as_string (GstState state) {
 
308
        gchar* result = NULL;
 
309
        switch (state) {
 
310
                case GST_STATE_PLAYING:
 
311
                {
 
312
                        gchar* _tmp0_;
 
313
                        _tmp0_ = g_strdup ("Playing");
 
314
                        result = _tmp0_;
 
315
                        return result;
 
316
                }
 
317
                case GST_STATE_PAUSED:
 
318
                {
 
319
                        gchar* _tmp1_;
 
320
                        _tmp1_ = g_strdup ("Paused");
 
321
                        result = _tmp1_;
 
322
                        return result;
 
323
                }
 
324
                case GST_STATE_NULL:
 
325
                {
 
326
                        gchar* _tmp2_;
 
327
                        _tmp2_ = g_strdup ("Stopped");
 
328
                        result = _tmp2_;
 
329
                        return result;
 
330
                }
 
331
                default:
 
332
                {
 
333
                        g_assert_not_reached ();
 
334
                }
 
335
        }
 
336
}
 
337
 
 
338
 
313
339
void player_toggle_play_pause (Player* self) {
314
340
        GstState state = 0;
315
341
        GstState _tmp0_;
433
459
}
434
460
 
435
461
 
436
 
static void _g_free0_ (gpointer var) {
437
 
        var = (g_free (var), NULL);
438
 
}
439
 
 
440
 
 
441
 
static void _g_variant_unref0_ (gpointer var) {
442
 
        (var == NULL) ? NULL : (var = (g_variant_unref (var), NULL));
443
 
}
444
 
 
445
 
 
446
 
static GVariant* _variant_new1 (const gchar* value) {
447
 
        return g_variant_ref_sink (g_variant_new_string (value));
448
 
}
449
 
 
450
 
 
451
 
static GVariant* _variant_new2 (const gchar* value) {
452
 
        return g_variant_ref_sink (g_variant_new_string (value));
453
 
}
454
 
 
455
 
 
456
 
static GVariant* _variant_new3 (const gchar* value) {
457
 
        return g_variant_ref_sink (g_variant_new_string (value));
458
 
}
459
 
 
460
 
 
461
 
static GVariant* _variant_new4 (gint32 value) {
462
 
        return g_variant_ref_sink (g_variant_new_int32 (value));
463
 
}
464
 
 
465
 
 
466
 
GHashTable* player_get_track_mpris_metadata (Player* self) {
467
 
        GHashTable* result = NULL;
468
 
        GHashTable* _tmp0_ = NULL;
469
 
        GHashTable* metadata;
470
 
        gchar* _tmp1_;
471
 
        gchar* _tmp2_;
472
 
        gchar* _tmp3_;
473
 
        gchar* _tmp4_;
474
 
        g_return_val_if_fail (self != NULL, NULL);
475
 
        _tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _g_variant_unref0_);
476
 
        metadata = _tmp0_;
477
 
        _tmp1_ = g_strdup ("xesam:album");
478
 
        g_hash_table_insert (metadata, _tmp1_, _variant_new1 (self->priv->_current_track->album));
479
 
        _tmp2_ = g_strdup ("xesam:artist");
480
 
        g_hash_table_insert (metadata, _tmp2_, _variant_new2 (self->priv->_current_track->artist));
481
 
        _tmp3_ = g_strdup ("xesam:title");
482
 
        g_hash_table_insert (metadata, _tmp3_, _variant_new3 (self->priv->_current_track->title));
483
 
        _tmp4_ = g_strdup ("xesam:trackNumber");
484
 
        g_hash_table_insert (metadata, _tmp4_, _variant_new4 ((gint32) self->priv->_current_track->number));
485
 
        result = metadata;
486
 
        return result;
487
 
}
488
 
 
489
 
 
490
462
Track* player_get_current_track (Player* self) {
491
463
        Track* result;
492
464
        g_return_val_if_fail (self != NULL, NULL);
597
569
        gchar* _tmp1_;
598
570
        gchar* _tmp2_;
599
571
        self->priv = PLAYER_GET_PRIVATE (self);
 
572
        self->priv->_current_track = NULL;
600
573
        _tmp0_ = gee_array_list_new (TYPE_TRACK, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
601
574
        self->priv->track_list = _tmp0_;
602
575
        self->priv->timeout = NULL;