← Back to branch summary

~ubuntu-branches/ubuntu/raring/rygel/raring

« back to all changes in this revision

Viewing changes to src/rygel/rygel-music-item.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson
  • Date: 2012-09-26 22:34:15 UTC
  • mfrom: (11.1.19 experimental)
  • Revision ID: package-import@ubuntu.com-20120926223415-9day2s783n9td4e8
Tags: 0.16.0-1
Imported Upstream version 0.16.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rygel/rygel-music-item.c
1
 
/* rygel-music-item.c generated by valac 0.14.2, the Vala compiler
2
 
 * generated from rygel-music-item.vala, do not modify */
3
 
 
4
 
/*
5
 
 * Copyright (C) 2008 Zeeshan Ali <zeenix@gmail.com>.
6
 
 * Copyright (C) 2010 Nokia Corporation.
7
 
 *
8
 
 * Author: Zeeshan Ali (Khattak) <zeeshanak@gnome.org>
9
 
 *                               <zeeshan.ali@nokia.com>
10
 
 *
11
 
 * This file is part of Rygel.
12
 
 *
13
 
 * Rygel is free software; you can redistribute it and/or modify
14
 
 * it under the terms of the GNU Lesser General Public License as published by
15
 
 * the Free Software Foundation; either version 2 of the License, or
16
 
 * (at your option) any later version.
17
 
 *
18
 
 * Rygel is distributed in the hope that it will be useful,
19
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21
 
 * GNU Lesser General Public License for more details.
22
 
 *
23
 
 * You should have received a copy of the GNU Lesser General Public License
24
 
 * along with this program; if not, write to the Free Software Foundation,
25
 
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
26
 
 */
27
 
 
28
 
#include <glib.h>
29
 
#include <glib-object.h>
30
 
#include <libgupnp-av/gupnp-av.h>
31
 
#include <stdlib.h>
32
 
#include <string.h>
33
 
#include <gee.h>
34
 
#include <gst/gst.h>
35
 
#include <gio/gio.h>
36
 
#include <libgupnp/gupnp.h>
37
 
#include <libgssdp/gssdp.h>
38
 
 
39
 
 
40
 
#define RYGEL_TYPE_MEDIA_OBJECT (rygel_media_object_get_type ())
41
 
#define RYGEL_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObject))
42
 
#define RYGEL_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
43
 
#define RYGEL_IS_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_OBJECT))
44
 
#define RYGEL_IS_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_OBJECT))
45
 
#define RYGEL_MEDIA_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
46
 
 
47
 
typedef struct _RygelMediaObject RygelMediaObject;
48
 
typedef struct _RygelMediaObjectClass RygelMediaObjectClass;
49
 
typedef struct _RygelMediaObjectPrivate RygelMediaObjectPrivate;
50
 
 
51
 
#define RYGEL_TYPE_TRANSCODE_MANAGER (rygel_transcode_manager_get_type ())
52
 
#define RYGEL_TRANSCODE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManager))
53
 
#define RYGEL_TRANSCODE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManagerClass))
54
 
#define RYGEL_IS_TRANSCODE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_TRANSCODE_MANAGER))
55
 
#define RYGEL_IS_TRANSCODE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_TRANSCODE_MANAGER))
56
 
#define RYGEL_TRANSCODE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManagerClass))
57
 
 
58
 
typedef struct _RygelTranscodeManager RygelTranscodeManager;
59
 
typedef struct _RygelTranscodeManagerClass RygelTranscodeManagerClass;
60
 
 
61
 
#define RYGEL_TYPE_HTTP_SERVER (rygel_http_server_get_type ())
62
 
#define RYGEL_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServer))
63
 
#define RYGEL_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
64
 
#define RYGEL_IS_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_SERVER))
65
 
#define RYGEL_IS_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_SERVER))
66
 
#define RYGEL_HTTP_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
67
 
 
68
 
typedef struct _RygelHTTPServer RygelHTTPServer;
69
 
typedef struct _RygelHTTPServerClass RygelHTTPServerClass;
70
 
 
71
 
#define RYGEL_TYPE_MEDIA_CONTAINER (rygel_media_container_get_type ())
72
 
#define RYGEL_MEDIA_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainer))
73
 
#define RYGEL_MEDIA_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainerClass))
74
 
#define RYGEL_IS_MEDIA_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_CONTAINER))
75
 
#define RYGEL_IS_MEDIA_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_CONTAINER))
76
 
#define RYGEL_MEDIA_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainerClass))
77
 
 
78
 
typedef struct _RygelMediaContainer RygelMediaContainer;
79
 
typedef struct _RygelMediaContainerClass RygelMediaContainerClass;
80
 
 
81
 
#define RYGEL_TYPE_MEDIA_ITEM (rygel_media_item_get_type ())
82
 
#define RYGEL_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItem))
83
 
#define RYGEL_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
84
 
#define RYGEL_IS_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_ITEM))
85
 
#define RYGEL_IS_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_ITEM))
86
 
#define RYGEL_MEDIA_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
87
 
 
88
 
typedef struct _RygelMediaItem RygelMediaItem;
89
 
typedef struct _RygelMediaItemClass RygelMediaItemClass;
90
 
typedef struct _RygelMediaItemPrivate RygelMediaItemPrivate;
91
 
 
92
 
#define RYGEL_TYPE_AUDIO_ITEM (rygel_audio_item_get_type ())
93
 
#define RYGEL_AUDIO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItem))
94
 
#define RYGEL_AUDIO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItemClass))
95
 
#define RYGEL_IS_AUDIO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_AUDIO_ITEM))
96
 
#define RYGEL_IS_AUDIO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_AUDIO_ITEM))
97
 
#define RYGEL_AUDIO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItemClass))
98
 
 
99
 
typedef struct _RygelAudioItem RygelAudioItem;
100
 
typedef struct _RygelAudioItemClass RygelAudioItemClass;
101
 
typedef struct _RygelAudioItemPrivate RygelAudioItemPrivate;
102
 
 
103
 
#define RYGEL_TYPE_MUSIC_ITEM (rygel_music_item_get_type ())
104
 
#define RYGEL_MUSIC_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItem))
105
 
#define RYGEL_MUSIC_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItemClass))
106
 
#define RYGEL_IS_MUSIC_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MUSIC_ITEM))
107
 
#define RYGEL_IS_MUSIC_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MUSIC_ITEM))
108
 
#define RYGEL_MUSIC_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItemClass))
109
 
 
110
 
typedef struct _RygelMusicItem RygelMusicItem;
111
 
typedef struct _RygelMusicItemClass RygelMusicItemClass;
112
 
typedef struct _RygelMusicItemPrivate RygelMusicItemPrivate;
113
 
 
114
 
#define RYGEL_TYPE_ICON_INFO (rygel_icon_info_get_type ())
115
 
#define RYGEL_ICON_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_ICON_INFO, RygelIconInfo))
116
 
#define RYGEL_ICON_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_ICON_INFO, RygelIconInfoClass))
117
 
#define RYGEL_IS_ICON_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_ICON_INFO))
118
 
#define RYGEL_IS_ICON_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_ICON_INFO))
119
 
#define RYGEL_ICON_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_ICON_INFO, RygelIconInfoClass))
120
 
 
121
 
typedef struct _RygelIconInfo RygelIconInfo;
122
 
typedef struct _RygelIconInfoClass RygelIconInfoClass;
123
 
 
124
 
#define RYGEL_TYPE_THUMBNAIL (rygel_thumbnail_get_type ())
125
 
#define RYGEL_THUMBNAIL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_THUMBNAIL, RygelThumbnail))
126
 
#define RYGEL_THUMBNAIL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_THUMBNAIL, RygelThumbnailClass))
127
 
#define RYGEL_IS_THUMBNAIL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_THUMBNAIL))
128
 
#define RYGEL_IS_THUMBNAIL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_THUMBNAIL))
129
 
#define RYGEL_THUMBNAIL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_THUMBNAIL, RygelThumbnailClass))
130
 
 
131
 
typedef struct _RygelThumbnail RygelThumbnail;
132
 
typedef struct _RygelThumbnailClass RygelThumbnailClass;
133
 
#define _g_free0(var) (var = (g_free (var), NULL))
134
 
#define _rygel_icon_info_unref0(var) ((var == NULL) ? NULL : (var = (rygel_icon_info_unref (var), NULL)))
135
 
 
136
 
#define RYGEL_TYPE_MEDIA_ART_STORE (rygel_media_art_store_get_type ())
137
 
#define RYGEL_MEDIA_ART_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_ART_STORE, RygelMediaArtStore))
138
 
#define RYGEL_MEDIA_ART_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_ART_STORE, RygelMediaArtStoreClass))
139
 
#define RYGEL_IS_MEDIA_ART_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_ART_STORE))
140
 
#define RYGEL_IS_MEDIA_ART_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_ART_STORE))
141
 
#define RYGEL_MEDIA_ART_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_ART_STORE, RygelMediaArtStoreClass))
142
 
 
143
 
typedef struct _RygelMediaArtStore RygelMediaArtStore;
144
 
typedef struct _RygelMediaArtStoreClass RygelMediaArtStoreClass;
145
 
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
146
 
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
147
 
typedef struct _RygelIconInfoPrivate RygelIconInfoPrivate;
148
 
typedef struct _RygelTranscodeManagerPrivate RygelTranscodeManagerPrivate;
149
 
 
150
 
#define RYGEL_TYPE_STATE_MACHINE (rygel_state_machine_get_type ())
151
 
#define RYGEL_STATE_MACHINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_STATE_MACHINE, RygelStateMachine))
152
 
#define RYGEL_IS_STATE_MACHINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_STATE_MACHINE))
153
 
#define RYGEL_STATE_MACHINE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), RYGEL_TYPE_STATE_MACHINE, RygelStateMachineIface))
154
 
 
155
 
typedef struct _RygelStateMachine RygelStateMachine;
156
 
typedef struct _RygelStateMachineIface RygelStateMachineIface;
157
 
typedef struct _RygelHTTPServerPrivate RygelHTTPServerPrivate;
158
 
 
159
 
struct _RygelMediaObject {
160
 
        GObject parent_instance;
161
 
        RygelMediaObjectPrivate * priv;
162
 
        gchar* id;
163
 
        gchar* ref_id;
164
 
        gchar* upnp_class;
165
 
        guint64 modified;
166
 
        GeeArrayList* uris;
167
 
        RygelMediaContainer* parent;
168
 
};
169
 
 
170
 
struct _RygelMediaObjectClass {
171
 
        GObjectClass parent_class;
172
 
        GUPnPDIDLLiteObject* (*serialize) (RygelMediaObject* self, GUPnPDIDLLiteWriter* writer, RygelHTTPServer* http_server, GError** error);
173
 
        gint (*compare_by_property) (RygelMediaObject* self, RygelMediaObject* media_object, const gchar* property);
174
 
        GUPnPOCMFlags (*get_ocm_flags) (RygelMediaObject* self);
175
 
};
176
 
 
177
 
struct _RygelMediaItem {
178
 
        RygelMediaObject parent_instance;
179
 
        RygelMediaItemPrivate * priv;
180
 
        gchar* date;
181
 
        gchar* mime_type;
182
 
        gchar* dlna_profile;
183
 
        GRegex* address_regex;
184
 
};
185
 
 
186
 
struct _RygelMediaItemClass {
187
 
        RygelMediaObjectClass parent_class;
188
 
        GstElement* (*create_stream_source) (RygelMediaItem* self, const gchar* host_ip);
189
 
        gboolean (*streamable) (RygelMediaItem* self);
190
 
        void (*add_uri) (RygelMediaItem* self, const gchar* uri);
191
 
        GUPnPDIDLLiteResource* (*add_resource) (RygelMediaItem* self, GUPnPDIDLLiteItem* didl_item, const gchar* uri, const gchar* protocol, const gchar* import_uri, GError** error);
192
 
        void (*add_proxy_resources) (RygelMediaItem* self, RygelHTTPServer* server, GUPnPDIDLLiteItem* didl_item, GError** error);
193
 
        GUPnPProtocolInfo* (*get_protocol_info) (RygelMediaItem* self, const gchar* uri, const gchar* protocol);
194
 
        void (*add_resources) (RygelMediaItem* self, GUPnPDIDLLiteItem* didl_item, gboolean allow_internal, GError** error);
195
 
};
196
 
 
197
 
struct _RygelAudioItem {
198
 
        RygelMediaItem parent_instance;
199
 
        RygelAudioItemPrivate * priv;
200
 
        glong duration;
201
 
        gint bitrate;
202
 
        gint sample_freq;
203
 
        gint bits_per_sample;
204
 
        gint channels;
205
 
};
206
 
 
207
 
struct _RygelAudioItemClass {
208
 
        RygelMediaItemClass parent_class;
209
 
};
210
 
 
211
 
struct _RygelMusicItem {
212
 
        RygelAudioItem parent_instance;
213
 
        RygelMusicItemPrivate * priv;
214
 
        gchar* artist;
215
 
        gchar* album;
216
 
        gchar* genre;
217
 
        gint track_number;
218
 
        RygelThumbnail* album_art;
219
 
};
220
 
 
221
 
struct _RygelMusicItemClass {
222
 
        RygelAudioItemClass parent_class;
223
 
};
224
 
 
225
 
struct _RygelIconInfo {
226
 
        GTypeInstance parent_instance;
227
 
        volatile int ref_count;
228
 
        RygelIconInfoPrivate * priv;
229
 
        gchar* mime_type;
230
 
        gchar* uri;
231
 
        gchar* file_extension;
232
 
        gint64 size;
233
 
        gint width;
234
 
        gint height;
235
 
        gint depth;
236
 
};
237
 
 
238
 
struct _RygelIconInfoClass {
239
 
        GTypeClass parent_class;
240
 
        void (*finalize) (RygelIconInfo *self);
241
 
};
242
 
 
243
 
struct _RygelTranscodeManager {
244
 
        GObject parent_instance;
245
 
        RygelTranscodeManagerPrivate * priv;
246
 
};
247
 
 
248
 
struct _RygelTranscodeManagerClass {
249
 
        GObjectClass parent_class;
250
 
        gchar* (*create_uri_for_item) (RygelTranscodeManager* self, RygelMediaItem* item, gint thumbnail_index, gint subtitle_index, const gchar* transcode_target);
251
 
        gchar* (*get_protocol) (RygelTranscodeManager* self);
252
 
        GeeArrayList* (*get_protocol_info) (RygelTranscodeManager* self);
253
 
};
254
 
 
255
 
struct _RygelStateMachineIface {
256
 
        GTypeInterface parent_iface;
257
 
        void (*run) (RygelStateMachine* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
258
 
        void (*run_finish) (RygelStateMachine* self, GAsyncResult* _res_);
259
 
        GCancellable* (*get_cancellable) (RygelStateMachine* self);
260
 
        void (*set_cancellable) (RygelStateMachine* self, GCancellable* value);
261
 
};
262
 
 
263
 
struct _RygelHTTPServer {
264
 
        RygelTranscodeManager parent_instance;
265
 
        RygelHTTPServerPrivate * priv;
266
 
        RygelMediaContainer* root_container;
267
 
        GUPnPContext* context;
268
 
};
269
 
 
270
 
struct _RygelHTTPServerClass {
271
 
        RygelTranscodeManagerClass parent_class;
272
 
};
273
 
 
274
 
 
275
 
static gpointer rygel_music_item_parent_class = NULL;
276
 
 
277
 
GType rygel_media_object_get_type (void) G_GNUC_CONST;
278
 
GType rygel_transcode_manager_get_type (void) G_GNUC_CONST;
279
 
GType rygel_http_server_get_type (void) G_GNUC_CONST;
280
 
GType rygel_media_container_get_type (void) G_GNUC_CONST;
281
 
GType rygel_media_item_get_type (void) G_GNUC_CONST;
282
 
GType rygel_audio_item_get_type (void) G_GNUC_CONST;
283
 
GType rygel_music_item_get_type (void) G_GNUC_CONST;
284
 
gpointer rygel_icon_info_ref (gpointer instance);
285
 
void rygel_icon_info_unref (gpointer instance);
286
 
GParamSpec* rygel_param_spec_icon_info (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
287
 
void rygel_value_set_icon_info (GValue* value, gpointer v_object);
288
 
void rygel_value_take_icon_info (GValue* value, gpointer v_object);
289
 
gpointer rygel_value_get_icon_info (const GValue* value);
290
 
GType rygel_icon_info_get_type (void) G_GNUC_CONST;
291
 
GType rygel_thumbnail_get_type (void) G_GNUC_CONST;
292
 
enum  {
293
 
        RYGEL_MUSIC_ITEM_DUMMY_PROPERTY
294
 
};
295
 
#define RYGEL_MUSIC_ITEM_UPNP_CLASS "object.item.audioItem.musicTrack"
296
 
RygelMusicItem* rygel_music_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class);
297
 
RygelMusicItem* rygel_music_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class);
298
 
RygelAudioItem* rygel_audio_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class);
299
 
RygelAudioItem* rygel_audio_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class);
300
 
void rygel_music_item_lookup_album_art (RygelMusicItem* self);
301
 
GType rygel_media_art_store_get_type (void) G_GNUC_CONST;
302
 
RygelMediaArtStore* rygel_media_art_store_get_default (void);
303
 
RygelThumbnail* rygel_media_art_store_find_media_art_any (RygelMediaArtStore* self, RygelMusicItem* item, GError** error);
304
 
static void rygel_music_item_real_add_resources (RygelMediaItem* base, GUPnPDIDLLiteItem* didl_item, gboolean allow_internal, GError** error);
305
 
void rygel_media_item_add_resources (RygelMediaItem* self, GUPnPDIDLLiteItem* didl_item, gboolean allow_internal, GError** error);
306
 
gchar* rygel_media_item_get_protocol_for_uri (RygelMediaItem* self, const gchar* uri, GError** error);
307
 
static gint rygel_music_item_real_compare_by_property (RygelMediaObject* base, RygelMediaObject* media_object, const gchar* property);
308
 
gint rygel_media_object_compare_string_props (RygelMediaObject* self, const gchar* prop1, const gchar* prop2);
309
 
gint rygel_media_object_compare_int_props (RygelMediaObject* self, gint prop1, gint prop2);
310
 
gint rygel_media_object_compare_by_property (RygelMediaObject* self, RygelMediaObject* media_object, const gchar* property);
311
 
static GUPnPDIDLLiteObject* rygel_music_item_real_serialize (RygelMediaObject* base, GUPnPDIDLLiteWriter* writer, RygelHTTPServer* http_server, GError** error);
312
 
GUPnPDIDLLiteObject* rygel_media_object_serialize (RygelMediaObject* self, GUPnPDIDLLiteWriter* writer, RygelHTTPServer* http_server, GError** error);
313
 
GType rygel_state_machine_get_type (void) G_GNUC_CONST;
314
 
static void rygel_music_item_real_add_proxy_resources (RygelMediaItem* base, RygelHTTPServer* server, GUPnPDIDLLiteItem* didl_item, GError** error);
315
 
void rygel_media_item_add_proxy_resources (RygelMediaItem* self, RygelHTTPServer* server, GUPnPDIDLLiteItem* didl_item, GError** error);
316
 
gboolean rygel_media_item_get_place_holder (RygelMediaItem* self);
317
 
gboolean rygel_http_server_need_proxy (RygelHTTPServer* self, const gchar* uri);
318
 
gchar* rygel_transcode_manager_create_uri_for_item (RygelTranscodeManager* self, RygelMediaItem* item, gint thumbnail_index, gint subtitle_index, const gchar* transcode_target);
319
 
static void rygel_music_item_finalize (GObject* obj);
320
 
 
321
 
 
322
 
RygelMusicItem* rygel_music_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class) {
323
 
        RygelMusicItem * self = NULL;
324
 
        const gchar* _tmp0_;
325
 
        RygelMediaContainer* _tmp1_;
326
 
        const gchar* _tmp2_;
327
 
        const gchar* _tmp3_;
328
 
        g_return_val_if_fail (id != NULL, NULL);
329
 
        g_return_val_if_fail (parent != NULL, NULL);
330
 
        g_return_val_if_fail (title != NULL, NULL);
331
 
        g_return_val_if_fail (upnp_class != NULL, NULL);
332
 
        _tmp0_ = id;
333
 
        _tmp1_ = parent;
334
 
        _tmp2_ = title;
335
 
        _tmp3_ = upnp_class;
336
 
        self = (RygelMusicItem*) rygel_audio_item_construct (object_type, _tmp0_, _tmp1_, _tmp2_, _tmp3_);
337
 
        return self;
338
 
}
339
 
 
340
 
 
341
 
RygelMusicItem* rygel_music_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class) {
342
 
        return rygel_music_item_construct (RYGEL_TYPE_MUSIC_ITEM, id, parent, title, upnp_class);
343
 
}
344
 
 
345
 
 
346
 
void rygel_music_item_lookup_album_art (RygelMusicItem* self) {
347
 
        RygelThumbnail* _tmp0_;
348
 
        RygelMediaArtStore* _tmp1_ = NULL;
349
 
        RygelMediaArtStore* media_art_store;
350
 
        RygelMediaArtStore* _tmp2_;
351
 
        GError * _inner_error_ = NULL;
352
 
        g_return_if_fail (self != NULL);
353
 
        _tmp0_ = self->album_art;
354
 
        g_assert (_tmp0_ == NULL);
355
 
        _tmp1_ = rygel_media_art_store_get_default ();
356
 
        media_art_store = _tmp1_;
357
 
        _tmp2_ = media_art_store;
358
 
        if (_tmp2_ == NULL) {
359
 
                _g_object_unref0 (media_art_store);
360
 
                return;
361
 
        }
362
 
        {
363
 
                RygelMediaArtStore* _tmp3_;
364
 
                RygelThumbnail* _tmp4_ = NULL;
365
 
                RygelThumbnail* _tmp5_;
366
 
                _tmp3_ = media_art_store;
367
 
                _tmp4_ = rygel_media_art_store_find_media_art_any (_tmp3_, self, &_inner_error_);
368
 
                _tmp5_ = _tmp4_;
369
 
                if (_inner_error_ != NULL) {
370
 
                        goto __catch58_g_error;
371
 
                }
372
 
                _rygel_icon_info_unref0 (self->album_art);
373
 
                self->album_art = _tmp5_;
374
 
        }
375
 
        goto __finally58;
376
 
        __catch58_g_error:
377
 
        {
378
 
                GError* err = NULL;
379
 
                err = _inner_error_;
380
 
                _inner_error_ = NULL;
381
 
                _g_error_free0 (err);
382
 
        }
383
 
        __finally58:
384
 
        if (_inner_error_ != NULL) {
385
 
                _g_object_unref0 (media_art_store);
386
 
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
387
 
                g_clear_error (&_inner_error_);
388
 
                return;
389
 
        }
390
 
        _g_object_unref0 (media_art_store);
391
 
}
392
 
 
393
 
 
394
 
static void rygel_music_item_real_add_resources (RygelMediaItem* base, GUPnPDIDLLiteItem* didl_item, gboolean allow_internal, GError** error) {
395
 
        RygelMusicItem * self;
396
 
        GUPnPDIDLLiteItem* _tmp0_;
397
 
        gboolean _tmp1_;
398
 
        RygelThumbnail* _tmp2_;
399
 
        GError * _inner_error_ = NULL;
400
 
        self = (RygelMusicItem*) base;
401
 
        g_return_if_fail (didl_item != NULL);
402
 
        _tmp0_ = didl_item;
403
 
        _tmp1_ = allow_internal;
404
 
        RYGEL_MEDIA_ITEM_CLASS (rygel_music_item_parent_class)->add_resources ((RygelMediaItem*) RYGEL_AUDIO_ITEM (self), _tmp0_, _tmp1_, &_inner_error_);
405
 
        if (_inner_error_ != NULL) {
406
 
                g_propagate_error (error, _inner_error_);
407
 
                return;
408
 
        }
409
 
        _tmp2_ = self->album_art;
410
 
        if (_tmp2_ != NULL) {
411
 
                RygelThumbnail* _tmp3_;
412
 
                const gchar* _tmp4_;
413
 
                gchar* _tmp5_ = NULL;
414
 
                gchar* protocol;
415
 
                gboolean _tmp6_ = FALSE;
416
 
                gboolean _tmp7_;
417
 
                gboolean _tmp9_;
418
 
                _tmp3_ = self->album_art;
419
 
                _tmp4_ = ((RygelIconInfo*) _tmp3_)->uri;
420
 
                _tmp5_ = rygel_media_item_get_protocol_for_uri ((RygelMediaItem*) self, _tmp4_, &_inner_error_);
421
 
                protocol = _tmp5_;
422
 
                if (_inner_error_ != NULL) {
423
 
                        g_propagate_error (error, _inner_error_);
424
 
                        return;
425
 
                }
426
 
                _tmp7_ = allow_internal;
427
 
                if (_tmp7_) {
428
 
                        _tmp6_ = TRUE;
429
 
                } else {
430
 
                        const gchar* _tmp8_;
431
 
                        _tmp8_ = protocol;
432
 
                        _tmp6_ = g_strcmp0 (_tmp8_, "internal") != 0;
433
 
                }
434
 
                _tmp9_ = _tmp6_;
435
 
                if (_tmp9_) {
436
 
                        GUPnPDIDLLiteItem* _tmp10_;
437
 
                        RygelThumbnail* _tmp11_;
438
 
                        const gchar* _tmp12_;
439
 
                        _tmp10_ = didl_item;
440
 
                        _tmp11_ = self->album_art;
441
 
                        _tmp12_ = ((RygelIconInfo*) _tmp11_)->uri;
442
 
                        gupnp_didl_lite_object_set_album_art ((GUPnPDIDLLiteObject*) _tmp10_, _tmp12_);
443
 
                }
444
 
                _g_free0 (protocol);
445
 
        }
446
 
}
447
 
 
448
 
 
449
 
static gpointer _g_object_ref0 (gpointer self) {
450
 
        return self ? g_object_ref (self) : NULL;
451
 
}
452
 
 
453
 
 
454
 
static gint rygel_music_item_real_compare_by_property (RygelMediaObject* base, RygelMediaObject* media_object, const gchar* property) {
455
 
        RygelMusicItem * self;
456
 
        gint result = 0;
457
 
        RygelMediaObject* _tmp0_;
458
 
        RygelMediaObject* _tmp1_;
459
 
        RygelMusicItem* _tmp2_;
460
 
        RygelMusicItem* item;
461
 
        const gchar* _tmp3_;
462
 
        const gchar* _tmp4_;
463
 
        GQuark _tmp6_ = 0U;
464
 
        static GQuark _tmp5_label0 = 0;
465
 
        static GQuark _tmp5_label1 = 0;
466
 
        static GQuark _tmp5_label2 = 0;
467
 
        self = (RygelMusicItem*) base;
468
 
        g_return_val_if_fail (media_object != NULL, 0);
469
 
        g_return_val_if_fail (property != NULL, 0);
470
 
        _tmp0_ = media_object;
471
 
        if (!RYGEL_IS_MUSIC_ITEM (_tmp0_)) {
472
 
                result = 1;
473
 
                return result;
474
 
        }
475
 
        _tmp1_ = media_object;
476
 
        _tmp2_ = _g_object_ref0 (RYGEL_IS_MUSIC_ITEM (_tmp1_) ? ((RygelMusicItem*) _tmp1_) : NULL);
477
 
        item = _tmp2_;
478
 
        _tmp3_ = property;
479
 
        _tmp4_ = _tmp3_;
480
 
        _tmp6_ = (NULL == _tmp4_) ? 0 : g_quark_from_string (_tmp4_);
481
 
        if (_tmp6_ == ((0 != _tmp5_label0) ? _tmp5_label0 : (_tmp5_label0 = g_quark_from_static_string ("dc:artist")))) {
482
 
                switch (0) {
483
 
                        default:
484
 
                        {
485
 
                                const gchar* _tmp7_;
486
 
                                RygelMusicItem* _tmp8_;
487
 
                                const gchar* _tmp9_;
488
 
                                gint _tmp10_ = 0;
489
 
                                _tmp7_ = self->artist;
490
 
                                _tmp8_ = item;
491
 
                                _tmp9_ = _tmp8_->artist;
492
 
                                _tmp10_ = rygel_media_object_compare_string_props ((RygelMediaObject*) self, _tmp7_, _tmp9_);
493
 
                                result = _tmp10_;
494
 
                                _g_object_unref0 (item);
495
 
                                return result;
496
 
                        }
497
 
                }
498
 
        } else if (_tmp6_ == ((0 != _tmp5_label1) ? _tmp5_label1 : (_tmp5_label1 = g_quark_from_static_string ("upnp:album")))) {
499
 
                switch (0) {
500
 
                        default:
501
 
                        {
502
 
                                const gchar* _tmp11_;
503
 
                                RygelMusicItem* _tmp12_;
504
 
                                const gchar* _tmp13_;
505
 
                                gint _tmp14_ = 0;
506
 
                                _tmp11_ = self->album;
507
 
                                _tmp12_ = item;
508
 
                                _tmp13_ = _tmp12_->album;
509
 
                                _tmp14_ = rygel_media_object_compare_string_props ((RygelMediaObject*) self, _tmp11_, _tmp13_);
510
 
                                result = _tmp14_;
511
 
                                _g_object_unref0 (item);
512
 
                                return result;
513
 
                        }
514
 
                }
515
 
        } else if (_tmp6_ == ((0 != _tmp5_label2) ? _tmp5_label2 : (_tmp5_label2 = g_quark_from_static_string ("upnp:originalTrackNumber")))) {
516
 
                switch (0) {
517
 
                        default:
518
 
                        {
519
 
                                gint _tmp15_;
520
 
                                RygelMusicItem* _tmp16_;
521
 
                                gint _tmp17_;
522
 
                                gint _tmp18_ = 0;
523
 
                                _tmp15_ = self->track_number;
524
 
                                _tmp16_ = item;
525
 
                                _tmp17_ = _tmp16_->track_number;
526
 
                                _tmp18_ = rygel_media_object_compare_int_props ((RygelMediaObject*) self, _tmp15_, _tmp17_);
527
 
                                result = _tmp18_;
528
 
                                _g_object_unref0 (item);
529
 
                                return result;
530
 
                        }
531
 
                }
532
 
        } else {
533
 
                switch (0) {
534
 
                        default:
535
 
                        {
536
 
                                RygelMusicItem* _tmp19_;
537
 
                                const gchar* _tmp20_;
538
 
                                gint _tmp21_ = 0;
539
 
                                _tmp19_ = item;
540
 
                                _tmp20_ = property;
541
 
                                _tmp21_ = RYGEL_MEDIA_OBJECT_CLASS (rygel_music_item_parent_class)->compare_by_property ((RygelMediaObject*) RYGEL_AUDIO_ITEM (self), (RygelMediaObject*) _tmp19_, _tmp20_);
542
 
                                result = _tmp21_;
543
 
                                _g_object_unref0 (item);
544
 
                                return result;
545
 
                        }
546
 
                }
547
 
        }
548
 
        _g_object_unref0 (item);
549
 
}
550
 
 
551
 
 
552
 
static GUPnPDIDLLiteObject* rygel_music_item_real_serialize (RygelMediaObject* base, GUPnPDIDLLiteWriter* writer, RygelHTTPServer* http_server, GError** error) {
553
 
        RygelMusicItem * self;
554
 
        GUPnPDIDLLiteObject* result = NULL;
555
 
        GUPnPDIDLLiteWriter* _tmp0_;
556
 
        RygelHTTPServer* _tmp1_;
557
 
        GUPnPDIDLLiteObject* _tmp2_ = NULL;
558
 
        GUPnPDIDLLiteObject* didl_item;
559
 
        gboolean _tmp3_ = FALSE;
560
 
        const gchar* _tmp4_;
561
 
        gboolean _tmp6_;
562
 
        gint _tmp11_;
563
 
        gboolean _tmp14_ = FALSE;
564
 
        const gchar* _tmp15_;
565
 
        gboolean _tmp17_;
566
 
        gboolean _tmp20_ = FALSE;
567
 
        const gchar* _tmp21_;
568
 
        gboolean _tmp23_;
569
 
        GUPnPDIDLLiteObject* _tmp26_;
570
 
        const gchar* _tmp27_;
571
 
        const gchar* _tmp28_;
572
 
        GError * _inner_error_ = NULL;
573
 
        self = (RygelMusicItem*) base;
574
 
        g_return_val_if_fail (writer != NULL, NULL);
575
 
        g_return_val_if_fail (http_server != NULL, NULL);
576
 
        _tmp0_ = writer;
577
 
        _tmp1_ = http_server;
578
 
        _tmp2_ = RYGEL_MEDIA_OBJECT_CLASS (rygel_music_item_parent_class)->serialize ((RygelMediaObject*) RYGEL_AUDIO_ITEM (self), _tmp0_, _tmp1_, &_inner_error_);
579
 
        didl_item = _tmp2_;
580
 
        if (_inner_error_ != NULL) {
581
 
                g_propagate_error (error, _inner_error_);
582
 
                return NULL;
583
 
        }
584
 
        _tmp4_ = self->artist;
585
 
        if (_tmp4_ != NULL) {
586
 
                const gchar* _tmp5_;
587
 
                _tmp5_ = self->artist;
588
 
                _tmp3_ = g_strcmp0 (_tmp5_, "") != 0;
589
 
        } else {
590
 
                _tmp3_ = FALSE;
591
 
        }
592
 
        _tmp6_ = _tmp3_;
593
 
        if (_tmp6_) {
594
 
                GUPnPDIDLLiteObject* _tmp7_;
595
 
                GUPnPDIDLLiteContributor* _tmp8_ = NULL;
596
 
                GUPnPDIDLLiteContributor* contributor;
597
 
                GUPnPDIDLLiteContributor* _tmp9_;
598
 
                const gchar* _tmp10_;
599
 
                _tmp7_ = didl_item;
600
 
                _tmp8_ = gupnp_didl_lite_object_add_artist (_tmp7_);
601
 
                contributor = _tmp8_;
602
 
                _tmp9_ = contributor;
603
 
                _tmp10_ = self->artist;
604
 
                gupnp_didl_lite_contributor_set_name (_tmp9_, _tmp10_);
605
 
                _g_object_unref0 (contributor);
606
 
        }
607
 
        _tmp11_ = self->track_number;
608
 
        if (_tmp11_ >= 0) {
609
 
                GUPnPDIDLLiteObject* _tmp12_;
610
 
                gint _tmp13_;
611
 
                _tmp12_ = didl_item;
612
 
                _tmp13_ = self->track_number;
613
 
                gupnp_didl_lite_object_set_track_number (_tmp12_, _tmp13_);
614
 
        }
615
 
        _tmp15_ = self->album;
616
 
        if (_tmp15_ != NULL) {
617
 
                const gchar* _tmp16_;
618
 
                _tmp16_ = self->album;
619
 
                _tmp14_ = g_strcmp0 (_tmp16_, "") != 0;
620
 
        } else {
621
 
                _tmp14_ = FALSE;
622
 
        }
623
 
        _tmp17_ = _tmp14_;
624
 
        if (_tmp17_) {
625
 
                GUPnPDIDLLiteObject* _tmp18_;
626
 
                const gchar* _tmp19_;
627
 
                _tmp18_ = didl_item;
628
 
                _tmp19_ = self->album;
629
 
                gupnp_didl_lite_object_set_album (_tmp18_, _tmp19_);
630
 
        }
631
 
        _tmp21_ = self->genre;
632
 
        if (_tmp21_ != NULL) {
633
 
                const gchar* _tmp22_;
634
 
                _tmp22_ = self->genre;
635
 
                _tmp20_ = g_strcmp0 (_tmp22_, "") != 0;
636
 
        } else {
637
 
                _tmp20_ = FALSE;
638
 
        }
639
 
        _tmp23_ = _tmp20_;
640
 
        if (_tmp23_) {
641
 
                GUPnPDIDLLiteObject* _tmp24_;
642
 
                const gchar* _tmp25_;
643
 
                _tmp24_ = didl_item;
644
 
                _tmp25_ = self->genre;
645
 
                gupnp_didl_lite_object_set_genre (_tmp24_, _tmp25_);
646
 
        }
647
 
        _tmp26_ = didl_item;
648
 
        _tmp27_ = gupnp_didl_lite_object_get_album_art (_tmp26_);
649
 
        _tmp28_ = _tmp27_;
650
 
        if (_tmp28_ != NULL) {
651
 
                GRegex* _tmp29_;
652
 
                GUPnPDIDLLiteObject* _tmp30_;
653
 
                const gchar* _tmp31_;
654
 
                const gchar* _tmp32_;
655
 
                RygelHTTPServer* _tmp33_;
656
 
                GUPnPContext* _tmp34_;
657
 
                const gchar* _tmp35_;
658
 
                const gchar* _tmp36_;
659
 
                gchar* _tmp37_ = NULL;
660
 
                gchar* _tmp38_;
661
 
                GUPnPDIDLLiteObject* _tmp39_;
662
 
                gchar* _tmp40_;
663
 
                _tmp29_ = ((RygelMediaItem*) self)->address_regex;
664
 
                _tmp30_ = didl_item;
665
 
                _tmp31_ = gupnp_didl_lite_object_get_album_art (_tmp30_);
666
 
                _tmp32_ = _tmp31_;
667
 
                _tmp33_ = http_server;
668
 
                _tmp34_ = _tmp33_->context;
669
 
                _tmp35_ = gssdp_client_get_host_ip ((GSSDPClient*) _tmp34_);
670
 
                _tmp36_ = _tmp35_;
671
 
                _tmp37_ = g_regex_replace_literal (_tmp29_, _tmp32_, (gssize) (-1), 0, _tmp36_, 0, &_inner_error_);
672
 
                _tmp38_ = _tmp37_;
673
 
                if (_inner_error_ != NULL) {
674
 
                        g_propagate_error (error, _inner_error_);
675
 
                        _g_object_unref0 (didl_item);
676
 
                        return NULL;
677
 
                }
678
 
                _tmp39_ = didl_item;
679
 
                _tmp40_ = _tmp38_;
680
 
                gupnp_didl_lite_object_set_album_art (_tmp39_, _tmp40_);
681
 
                _g_free0 (_tmp40_);
682
 
        }
683
 
        result = didl_item;
684
 
        return result;
685
 
}
686
 
 
687
 
 
688
 
static void rygel_music_item_real_add_proxy_resources (RygelMediaItem* base, RygelHTTPServer* server, GUPnPDIDLLiteItem* didl_item, GError** error) {
689
 
        RygelMusicItem * self;
690
 
        RygelHTTPServer* _tmp0_;
691
 
        GUPnPDIDLLiteItem* _tmp1_;
692
 
        gboolean _tmp2_ = FALSE;
693
 
        gboolean _tmp3_ = FALSE;
694
 
        gboolean _tmp4_;
695
 
        gboolean _tmp5_;
696
 
        gboolean _tmp7_;
697
 
        gboolean _tmp12_;
698
 
        GError * _inner_error_ = NULL;
699
 
        self = (RygelMusicItem*) base;
700
 
        g_return_if_fail (server != NULL);
701
 
        g_return_if_fail (didl_item != NULL);
702
 
        _tmp0_ = server;
703
 
        _tmp1_ = didl_item;
704
 
        RYGEL_MEDIA_ITEM_CLASS (rygel_music_item_parent_class)->add_proxy_resources ((RygelMediaItem*) RYGEL_AUDIO_ITEM (self), _tmp0_, _tmp1_, &_inner_error_);
705
 
        if (_inner_error_ != NULL) {
706
 
                g_propagate_error (error, _inner_error_);
707
 
                return;
708
 
        }
709
 
        _tmp4_ = rygel_media_item_get_place_holder ((RygelMediaItem*) self);
710
 
        _tmp5_ = _tmp4_;
711
 
        if (!_tmp5_) {
712
 
                RygelThumbnail* _tmp6_;
713
 
                _tmp6_ = self->album_art;
714
 
                _tmp3_ = _tmp6_ != NULL;
715
 
        } else {
716
 
                _tmp3_ = FALSE;
717
 
        }
718
 
        _tmp7_ = _tmp3_;
719
 
        if (_tmp7_) {
720
 
                RygelHTTPServer* _tmp8_;
721
 
                RygelThumbnail* _tmp9_;
722
 
                const gchar* _tmp10_;
723
 
                gboolean _tmp11_ = FALSE;
724
 
                _tmp8_ = server;
725
 
                _tmp9_ = self->album_art;
726
 
                _tmp10_ = ((RygelIconInfo*) _tmp9_)->uri;
727
 
                _tmp11_ = rygel_http_server_need_proxy (_tmp8_, _tmp10_);
728
 
                _tmp2_ = _tmp11_;
729
 
        } else {
730
 
                _tmp2_ = FALSE;
731
 
        }
732
 
        _tmp12_ = _tmp2_;
733
 
        if (_tmp12_) {
734
 
                GUPnPDIDLLiteItem* _tmp13_;
735
 
                RygelHTTPServer* _tmp14_;
736
 
                gchar* _tmp15_ = NULL;
737
 
                gchar* _tmp16_;
738
 
                _tmp13_ = didl_item;
739
 
                _tmp14_ = server;
740
 
                _tmp15_ = rygel_transcode_manager_create_uri_for_item ((RygelTranscodeManager*) _tmp14_, (RygelMediaItem*) self, 0, -1, NULL);
741
 
                _tmp16_ = _tmp15_;
742
 
                gupnp_didl_lite_object_set_album_art ((GUPnPDIDLLiteObject*) _tmp13_, _tmp16_);
743
 
                _g_free0 (_tmp16_);
744
 
        }
745
 
}
746
 
 
747
 
 
748
 
static void rygel_music_item_class_init (RygelMusicItemClass * klass) {
749
 
        rygel_music_item_parent_class = g_type_class_peek_parent (klass);
750
 
        RYGEL_MEDIA_ITEM_CLASS (klass)->add_resources = rygel_music_item_real_add_resources;
751
 
        RYGEL_MEDIA_OBJECT_CLASS (klass)->compare_by_property = rygel_music_item_real_compare_by_property;
752
 
        RYGEL_MEDIA_OBJECT_CLASS (klass)->serialize = rygel_music_item_real_serialize;
753
 
        RYGEL_MEDIA_ITEM_CLASS (klass)->add_proxy_resources = rygel_music_item_real_add_proxy_resources;
754
 
        G_OBJECT_CLASS (klass)->finalize = rygel_music_item_finalize;
755
 
}
756
 
 
757
 
 
758
 
static void rygel_music_item_instance_init (RygelMusicItem * self) {
759
 
        self->track_number = -1;
760
 
}
761
 
 
762
 
 
763
 
static void rygel_music_item_finalize (GObject* obj) {
764
 
        RygelMusicItem * self;
765
 
        self = RYGEL_MUSIC_ITEM (obj);
766
 
        _g_free0 (self->artist);
767
 
        _g_free0 (self->album);
768
 
        _g_free0 (self->genre);
769
 
        _rygel_icon_info_unref0 (self->album_art);
770
 
        G_OBJECT_CLASS (rygel_music_item_parent_class)->finalize (obj);
771
 
}
772
 
 
773
 
 
774
 
/**
775
 
 * Represents a music item.
776
 
 */
777
 
GType rygel_music_item_get_type (void) {
778
 
        static volatile gsize rygel_music_item_type_id__volatile = 0;
779
 
        if (g_once_init_enter (&rygel_music_item_type_id__volatile)) {
780
 
                static const GTypeInfo g_define_type_info = { sizeof (RygelMusicItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_music_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelMusicItem), 0, (GInstanceInitFunc) rygel_music_item_instance_init, NULL };
781
 
                GType rygel_music_item_type_id;
782
 
                rygel_music_item_type_id = g_type_register_static (RYGEL_TYPE_AUDIO_ITEM, "RygelMusicItem", &g_define_type_info, 0);
783
 
                g_once_init_leave (&rygel_music_item_type_id__volatile, rygel_music_item_type_id);
784
 
        }
785
 
        return rygel_music_item_type_id__volatile;
786
 
}
787
 
 
788
 
 
789