← Back to branch summary

~ubuntu-branches/ubuntu/utopic/rhythmbox/utopic-proposed

« back to all changes in this revision

Viewing changes to metadata/monkey-media/monkey-media-stream-info.c

Tags: upstream-0.9.2
Import upstream version 0.9.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
metadata/monkey-media/monkey-media-stream-info.c
1
 
/*  monkey-sound
2
 
 *
3
 
 *  arch-tag: Implementation of song metadata loading object
4
 
 *
5
 
 *  Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org>
6
 
 *                     Marco Pesenti Gritti <marco@it.gnome.org>
7
 
 *                     Bastien Nocera <hadess@hadess.net>
8
 
 *                     Seth Nickell <snickell@stanford.edu>
9
 
 *
10
 
 *  This program is free software; you can redistribute it and/or modify
11
 
 *  it under the terms of the GNU General Public License as published by
12
 
 *  the Free Software Foundation; either version 2 of the License, or
13
 
 *  (at your option) any later version.
14
 
 *
15
 
 *  This program is distributed in the hope that it will be useful,
16
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
 
 *  GNU General Public License for more details.
19
 
 *
20
 
 *  You should have received a copy of the GNU General Public License
21
 
 *  along with this program; if not, write to the Free Software
22
 
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23
 
 *
24
 
 */
25
 
 
26
 
#include <glib.h>
27
 
#include <stdlib.h>
28
 
#include <stdio.h>
29
 
#include <string.h>
30
 
#include <unistd.h>
31
 
#include <libgnomevfs/gnome-vfs.h>
32
 
#include <libgnomevfs/gnome-vfs-mime-utils.h>
33
 
#include <libgnomevfs/gnome-vfs-utils.h>
34
 
 
35
 
#include "monkey-media-stream-info.h"
36
 
#include "monkey-media-private.h"
37
 
#ifdef HAVE_MUSICBRAINZ
38
 
#include "monkey-media-musicbrainz.h"
39
 
#endif
40
 
 
41
 
#include "vorbis-stream-info-impl.h"
42
 
#include "mp3-stream-info-impl.h"
43
 
#include "audiocd-stream-info-impl.h"
44
 
#include "flac-stream-info-impl.h"
45
 
 
46
 
static void monkey_media_stream_info_class_init (MonkeyMediaStreamInfoClass *klass);
47
 
static void monkey_media_stream_info_init (MonkeyMediaStreamInfo *info);
48
 
static void monkey_media_stream_info_finalize (GObject *object);
49
 
static void monkey_media_stream_info_set_property (GObject *object,
50
 
                                                   guint prop_id,
51
 
                                                   const GValue *value,
52
 
                                                   GParamSpec *pspec);
53
 
static void monkey_media_stream_info_get_property (GObject *object,
54
 
                                                   guint prop_id,
55
 
                                                   GValue *value,
56
 
                                                   GParamSpec *pspec);
57
 
 
58
 
GType
59
 
monkey_media_stream_info_field_get_type (void)
60
 
{
61
 
        static GType etype = 0;
62
 
 
63
 
        if (etype == 0)
64
 
        {
65
 
                static const GEnumValue values[] =
66
 
                {
67
 
                        /* tags */
68
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_TITLE,                   "MONKEY_MEDIA_STREAM_INFO_FIELD_TITLE",                   "title" },
69
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_ARTIST,                  "MONKEY_MEDIA_STREAM_INFO_FIELD_ARTIST",                  "artist" },
70
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_ALBUM,                   "MONKEY_MEDIA_STREAM_INFO_FIELD_ALBUM",                   "album" },
71
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_DATE,                    "MONKEY_MEDIA_STREAM_INFO_FIELD_DATE",                    "date" },
72
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_GENRE,                   "MONKEY_MEDIA_STREAM_INFO_FIELD_GENRE",                   "genre" },
73
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_COMMENT,                 "MONKEY_MEDIA_STREAM_INFO_FIELD_COMMENT",                 "comment" },
74
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_TRACK_NUMBER,            "MONKEY_MEDIA_STREAM_INFO_FIELD_TRACK_NUMBER",            "tracknumber" },
75
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_MAX_TRACK_NUMBER,        "MONKEY_MEDIA_STREAM_INFO_FIELD_MAX_TRACK_NUMBER",        "max_tracknumber" },
76
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_LOCATION,                "MONKEY_MEDIA_STREAM_INFO_FIELD_LOCATION",                "location" },
77
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_DESCRIPTION,             "MONKEY_MEDIA_STREAM_INFO_FIELD_DESCRIPTION",             "description" },
78
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VERSION,                 "MONKEY_MEDIA_STREAM_INFO_FIELD_VERSION",                 "version" },
79
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_ISRC,                    "MONKEY_MEDIA_STREAM_INFO_FIELD_ISRC",                    "isrc" },
80
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_ORGANIZATION,            "MONKEY_MEDIA_STREAM_INFO_FIELD_ORGANIZATION",            "organization" },
81
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_COPYRIGHT,               "MONKEY_MEDIA_STREAM_INFO_FIELD_COPYRIGHT",               "copyright" },
82
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_CONTACT,                 "MONKEY_MEDIA_STREAM_INFO_FIELD_CONTACT",                 "contact" },
83
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_LICENSE,                 "MONKEY_MEDIA_STREAM_INFO_FIELD_LICENSE",                 "license" },
84
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_PERFORMER,               "MONKEY_MEDIA_STREAM_INFO_FIELD_PERFORMER",               "performer" },
85
 
 
86
 
                        /* generic stream information */
87
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_FILE_SIZE,               "MONKEY_MEDIA_STREAM_INFO_FIELD_FILE_SIZE",               "filesize" },
88
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_DURATION,                "MONKEY_MEDIA_STREAM_INFO_FIELD_DURATION",                "duration" },
89
 
 
90
 
                        /* audio bits */
91
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_HAS_AUDIO,               "MONKEY_MEDIA_STREAM_INFO_FIELD_HAS_AUDIO",               "has_audio" },
92
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_CODEC_INFO,        "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_CODEC_INFO",        "audio_codecinfo" },
93
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_BIT_RATE,          "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_BIT_RATE",          "audio_bitrate" },
94
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_AVERAGE_BIT_RATE,  "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_AVERAGE_BIT_RATE",  "audio_average-bitrate" },
95
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_VARIABLE_BIT_RATE, "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_VARIABLE_BIT_RATE", "audio_variable-bitrate" },
96
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_QUALITY,           "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_QUALITY",           "audio_quality" },
97
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_SAMPLE_RATE,       "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_SAMPLE_RATE",       "audio_samplerate" },
98
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_CHANNELS,          "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_CHANNELS",          "audio_channels" },
99
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_VENDOR,            "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_VENDOR",            "audio_vendor" },
100
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_SERIAL_NUMBER,     "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_SERIAL_NUMBER",     "audio_serialnumber" },
101
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_ALBUM_GAIN,        "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_ALBUM_GAIN",        "audio_album_gain" },
102
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_TRACK_GAIN,        "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_TRACK_GAIN",        "audio_track_gain" },
103
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_ALBUM_PEAK,        "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_ALBUM_PEAK",        "audio_album_peak" },
104
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_TRACK_PEAK,        "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_TRACK_PEAK",        "audio_track_peak" },
105
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_TRM_ID,            "MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_TRM_ID",            "audio_trm_id" },
106
 
 
107
 
                        /* video bits */
108
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_HAS_VIDEO,               "MONKEY_MEDIA_STREAM_INFO_FIELD_HAS_VIDEO",               "has_video" },
109
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_CODEC_INFO,        "MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_CODEC_INFO",        "video_codecinfo" },
110
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_BIT_RATE,          "MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_BIT_RATE",          "video_bitrate" },
111
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_AVERAGE_BIT_RATE,  "MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_AVERAGE_BIT_RATE",  "video_average-bitrate" },
112
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_VARIABLE_BIT_RATE, "MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_VARIABLE_BIT_RATE", "video_variable-bitrate" },
113
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_WIDTH,             "MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_WIDTH",             "video_width" },
114
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_HEIGHT,            "MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_HEIGHT",            "video_height" },
115
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_SERIAL_NUMBER,     "MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_SERIAL_NUMBER",     "video_serialnumber" },
116
 
                        { MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_VENDOR,            "MONKEY_MEDIA_STREAM_INFO_FIELD_VIDEO_VENDOR",            "video_vendor" },
117
 
                        { 0, 0, 0 }
118
 
                };
119
 
 
120
 
                etype = g_enum_register_static ("MonkeyMediaStreamInfoField", values);
121
 
        }
122
 
 
123
 
        return etype;
124
 
}
125
 
 
126
 
gboolean
127
 
monkey_media_stream_info_uri_is_supported (const char *uri)
128
 
{
129
 
        char *mimetype;
130
 
 
131
 
        g_return_val_if_fail (uri != NULL, FALSE);
132
 
 
133
 
        return (monkey_media_get_stream_info_impl_for (uri, &mimetype) != -1);
134
 
}
135
 
 
136
 
GQuark
137
 
monkey_media_stream_info_error_quark (void)
138
 
{
139
 
        static GQuark quark;
140
 
        if (!quark)
141
 
                quark = g_quark_from_static_string ("monkey_media_stream_info_error");
142
 
 
143
 
        return quark;
144
 
}
145
 
 
146
 
struct MonkeyMediaStreamInfoPrivate
147
 
{
148
 
        char *location;
149
 
 
150
 
        GError *error;
151
 
};
152
 
 
153
 
enum
154
 
{
155
 
        PROP_0,
156
 
        PROP_LOCATION,
157
 
        PROP_ERROR
158
 
};
159
 
 
160
 
static GObjectClass *parent_class = NULL;
161
 
 
162
 
GType
163
 
monkey_media_stream_info_get_type (void)
164
 
{
165
 
        static GType monkey_media_stream_info_type = 0;
166
 
 
167
 
        if (monkey_media_stream_info_type == 0)
168
 
        {
169
 
                static const GTypeInfo our_info =
170
 
                {
171
 
                        sizeof (MonkeyMediaStreamInfoClass),
172
 
                        NULL,
173
 
                        NULL,
174
 
                        (GClassInitFunc) monkey_media_stream_info_class_init,
175
 
                        NULL,
176
 
                        NULL,
177
 
                        sizeof (MonkeyMediaStreamInfo),
178
 
                        0,
179
 
                        (GInstanceInitFunc) monkey_media_stream_info_init
180
 
                };
181
 
 
182
 
                monkey_media_stream_info_type = g_type_register_static (G_TYPE_OBJECT,
183
 
                                                                        "MonkeyMediaStreamInfo",
184
 
                                                                        &our_info, 0);
185
 
        }
186
 
 
187
 
        return monkey_media_stream_info_type;
188
 
}
189
 
 
190
 
static void
191
 
monkey_media_stream_info_class_init (MonkeyMediaStreamInfoClass *klass)
192
 
{
193
 
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
194
 
 
195
 
        parent_class = g_type_class_peek_parent (klass);
196
 
 
197
 
        object_class->finalize = monkey_media_stream_info_finalize;
198
 
 
199
 
        object_class->set_property = monkey_media_stream_info_set_property;
200
 
        object_class->get_property = monkey_media_stream_info_get_property;
201
 
 
202
 
        g_object_class_install_property (object_class,
203
 
                                         PROP_LOCATION,
204
 
                                         g_param_spec_string ("location",
205
 
                                                              "Loaded URI",
206
 
                                                              "Loaded URI",
207
 
                                                              NULL,
208
 
                                                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
209
 
        g_object_class_install_property (object_class,
210
 
                                         PROP_ERROR,
211
 
                                         g_param_spec_pointer ("error",
212
 
                                                               "Error",
213
 
                                                               "Failure information",
214
 
                                                               G_PARAM_READWRITE));
215
 
}
216
 
 
217
 
static void
218
 
monkey_media_stream_info_init (MonkeyMediaStreamInfo *info)
219
 
{
220
 
        info->priv = g_new0 (MonkeyMediaStreamInfoPrivate, 1);
221
 
}
222
 
 
223
 
static void
224
 
monkey_media_stream_info_finalize (GObject *object)
225
 
{
226
 
        MonkeyMediaStreamInfo *info;
227
 
 
228
 
        g_return_if_fail (object != NULL);
229
 
        g_return_if_fail (MONKEY_MEDIA_IS_STREAM_INFO (object));
230
 
 
231
 
        info = MONKEY_MEDIA_STREAM_INFO (object);
232
 
 
233
 
        g_return_if_fail (info->priv != NULL);
234
 
 
235
 
        g_free (info->priv->location);
236
 
 
237
 
        g_free (info->priv);
238
 
 
239
 
        G_OBJECT_CLASS (parent_class)->finalize (object);
240
 
}
241
 
 
242
 
static void
243
 
monkey_media_stream_info_set_property (GObject *object,
244
 
                                       guint prop_id,
245
 
                                       const GValue *value,
246
 
                                       GParamSpec *pspec)
247
 
{
248
 
        MonkeyMediaStreamInfo *info = MONKEY_MEDIA_STREAM_INFO (object);
249
 
 
250
 
        switch (prop_id)
251
 
        {
252
 
        case PROP_LOCATION:
253
 
                {
254
 
                        MonkeyMediaStreamInfoClass *klass = MONKEY_MEDIA_STREAM_INFO_GET_CLASS (info);
255
 
 
256
 
                        info->priv->location = g_strdup (g_value_get_string (value));
257
 
 
258
 
                        klass->open_stream (info);
259
 
                }
260
 
                break;
261
 
        case PROP_ERROR:
262
 
                info->priv->error = g_value_get_pointer (value);
263
 
                break;
264
 
        default:
265
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
266
 
                break;
267
 
        }
268
 
}
269
 
 
270
 
static void 
271
 
monkey_media_stream_info_get_property (GObject *object,
272
 
                                       guint prop_id,
273
 
                                       GValue *value,
274
 
                                       GParamSpec *pspec)
275
 
{
276
 
        MonkeyMediaStreamInfo *info = MONKEY_MEDIA_STREAM_INFO (object);
277
 
 
278
 
        switch (prop_id)
279
 
        {
280
 
        case PROP_LOCATION:
281
 
                g_value_set_string (value, info->priv->location);
282
 
                break;
283
 
        case PROP_ERROR:
284
 
                g_value_set_pointer (value, info->priv->error);
285
 
                break;
286
 
        default:
287
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
288
 
                break;
289
 
        }
290
 
}
291
 
 
292
 
MonkeyMediaStreamInfo *
293
 
monkey_media_stream_info_new (const char *uri, GError **error)
294
 
{
295
 
        MonkeyMediaStreamInfo *info = NULL;
296
 
        GType impl_type = -1;
297
 
        char *mimetype = NULL;
298
 
        GError *tmp;
299
 
 
300
 
        g_return_val_if_fail (uri != NULL, NULL);
301
 
 
302
 
        impl_type = monkey_media_get_stream_info_impl_for (uri, &mimetype);
303
 
 
304
 
        if (impl_type == -1)
305
 
        {
306
 
                if (mimetype)
307
 
                        g_set_error (error,
308
 
                                     MONKEY_MEDIA_STREAM_INFO_ERROR,
309
 
                                     MONKEY_MEDIA_STREAM_INFO_ERROR_UNSUPPORTED_MIME_TYPE,
310
 
                                     _("Unsupported MIME type %s"), mimetype);
311
 
                else
312
 
                        g_set_error (error,
313
 
                                     MONKEY_MEDIA_STREAM_INFO_ERROR,
314
 
                                     MONKEY_MEDIA_STREAM_INFO_ERROR_UNSUPPORTED_MIME_TYPE,
315
 
                                     _("Unknown file type"));
316
 
                return NULL;
317
 
        }
318
 
 
319
 
        info = MONKEY_MEDIA_STREAM_INFO (g_object_new (impl_type,
320
 
                                                       "location", uri,
321
 
                                                       NULL));
322
 
 
323
 
        g_return_val_if_fail (info->priv != NULL, NULL);
324
 
 
325
 
        g_object_get (G_OBJECT (info), "error", &tmp, NULL);
326
 
 
327
 
        if (tmp != NULL)
328
 
        {
329
 
                if (error != NULL)
330
 
                        *error = tmp;
331
 
                else
332
 
                        g_error_free (tmp);
333
 
 
334
 
                g_object_unref (G_OBJECT (info));
335
 
                info = NULL;
336
 
        }
337
 
 
338
 
        return info;
339
 
}
340
 
 
341
 
static gboolean
342
 
sanitize_values (gboolean ret,
343
 
                 MonkeyMediaStreamInfo *info,
344
 
                 MonkeyMediaStreamInfoField field,
345
 
                 GValue *value)
346
 
{
347
 
        if (ret == TRUE)
348
 
        {
349
 
                /* Convert "\0" to NULL */
350
 
                if (G_VALUE_HOLDS (value, G_TYPE_STRING))
351
 
                {
352
 
                        const char *str;
353
 
 
354
 
                        str = g_value_get_string (value);
355
 
                        if (str[0] != '\0')
356
 
                                return TRUE;
357
 
                } else {
358
 
                        return TRUE;
359
 
                }
360
 
 
361
 
                g_value_unset (value);
362
 
        }
363
 
 
364
 
        switch (field) 
365
 
        {
366
 
        case MONKEY_MEDIA_STREAM_INFO_FIELD_TITLE:
367
 
                {
368
 
                        GValue tracknum_value = { 0, };
369
 
                        int tracknum = 0;
370
 
                        
371
 
                        g_value_init (value, G_TYPE_STRING);
372
 
 
373
 
                        if (monkey_media_stream_info_get_value (info,
374
 
                                                                MONKEY_MEDIA_STREAM_INFO_FIELD_TRACK_NUMBER,
375
 
                                                                0,
376
 
                                                                &tracknum_value) == TRUE)
377
 
                        {
378
 
                                tracknum = g_value_get_int (&tracknum_value);
379
 
                                g_value_unset (&tracknum_value);
380
 
                        }
381
 
 
382
 
                        if (tracknum > 0)
383
 
                        {
384
 
                                char *name;
385
 
 
386
 
                                name = g_strdup_printf (_("Track %.2d"), tracknum);
387
 
                                g_value_set_string (value, name);
388
 
                                g_free (name);
389
 
                        }
390
 
                        else
391
 
                        {
392
 
                                char *basename;
393
 
                                char *unescaped_basename;
394
 
                                char *utf8_basename;
395
 
                        
396
 
                                basename = g_path_get_basename (info->priv->location);
397
 
                                unescaped_basename = gnome_vfs_unescape_string_for_display (basename);                  
398
 
                                utf8_basename = g_filename_to_utf8 (unescaped_basename,
399
 
                                                                    g_utf8_strlen (unescaped_basename, -1),
400
 
                                                                    NULL, NULL, NULL);
401
 
                                if (utf8_basename != NULL)
402
 
                                        g_value_set_string (value, utf8_basename);
403
 
                                else
404
 
                                        g_value_set_string (value, _("Unknown"));
405
 
                        
406
 
                                g_free (basename);
407
 
                                g_free (unescaped_basename);
408
 
                                g_free (utf8_basename);
409
 
                        }
410
 
 
411
 
                        ret = TRUE;
412
 
                }
413
 
                break;
414
 
        case MONKEY_MEDIA_STREAM_INFO_FIELD_ARTIST:
415
 
        case MONKEY_MEDIA_STREAM_INFO_FIELD_ALBUM:
416
 
        case MONKEY_MEDIA_STREAM_INFO_FIELD_GENRE:
417
 
        case MONKEY_MEDIA_STREAM_INFO_FIELD_ORGANIZATION:
418
 
        case MONKEY_MEDIA_STREAM_INFO_FIELD_COPYRIGHT:
419
 
                g_value_init (value, G_TYPE_STRING);
420
 
                g_value_set_string (value, _("Unknown"));
421
 
                ret = TRUE;
422
 
                break;
423
 
        default:
424
 
                ret = FALSE;
425
 
                break;
426
 
        }
427
 
 
428
 
        return ret;
429
 
}
430
 
 
431
 
int
432
 
monkey_media_stream_info_get_n_values (MonkeyMediaStreamInfo *info,
433
 
                                       MonkeyMediaStreamInfoField field)
434
 
{
435
 
        MonkeyMediaStreamInfoClass *klass;
436
 
        int ret;
437
 
 
438
 
        g_return_val_if_fail (MONKEY_MEDIA_IS_STREAM_INFO (info), 0);
439
 
 
440
 
        klass = MONKEY_MEDIA_STREAM_INFO_GET_CLASS (info);
441
 
 
442
 
        ret = klass->get_n_values (info, field);
443
 
 
444
 
        if (ret == 0 &&
445
 
            (field == MONKEY_MEDIA_STREAM_INFO_FIELD_TITLE ||
446
 
             field == MONKEY_MEDIA_STREAM_INFO_FIELD_ARTIST ||
447
 
             field == MONKEY_MEDIA_STREAM_INFO_FIELD_ALBUM ||
448
 
             field == MONKEY_MEDIA_STREAM_INFO_FIELD_GENRE ||
449
 
             field == MONKEY_MEDIA_STREAM_INFO_FIELD_ORGANIZATION ||
450
 
             field == MONKEY_MEDIA_STREAM_INFO_FIELD_COPYRIGHT))
451
 
        {
452
 
                ret = 1;
453
 
        }
454
 
 
455
 
        return ret;
456
 
}
457
 
 
458
 
GList *
459
 
monkey_media_stream_info_get_value_list (MonkeyMediaStreamInfo *info,
460
 
                                         MonkeyMediaStreamInfoField field)
461
 
{
462
 
        MonkeyMediaStreamInfoClass *klass;
463
 
        int i, max;
464
 
        GList *ret = NULL;
465
 
 
466
 
        g_return_val_if_fail (MONKEY_MEDIA_IS_STREAM_INFO (info), NULL);
467
 
 
468
 
        klass = MONKEY_MEDIA_STREAM_INFO_GET_CLASS (info);
469
 
 
470
 
        max = klass->get_n_values (info, field);
471
 
 
472
 
        for (i = 0; i < max; i++)
473
 
        {
474
 
                GValue *value;
475
 
 
476
 
                value = g_new0 (GValue, 1);
477
 
                
478
 
                klass->get_value (info, field, i, value);
479
 
 
480
 
                ret = g_list_append (ret, value);
481
 
        }
482
 
 
483
 
        return ret;
484
 
}
485
 
 
486
 
void
487
 
monkey_media_stream_info_free_value_list (GList *list)
488
 
{
489
 
        GList *l;
490
 
 
491
 
        for (l = list; l != NULL; l = g_list_next (l))
492
 
        {
493
 
                GValue *value;
494
 
                
495
 
                value = (GValue *) l->data;
496
 
 
497
 
                g_value_unset (value);
498
 
                g_free (value);
499
 
        }
500
 
 
501
 
        g_list_free (list);
502
 
}
503
 
 
504
 
gboolean
505
 
monkey_media_stream_info_get_value (MonkeyMediaStreamInfo *info,
506
 
                                    MonkeyMediaStreamInfoField field,
507
 
                                    int index,
508
 
                                    GValue *value)
509
 
{
510
 
        MonkeyMediaStreamInfoClass *klass;
511
 
        gboolean ret;
512
 
 
513
 
        g_return_val_if_fail (MONKEY_MEDIA_IS_STREAM_INFO (info), FALSE);
514
 
 
515
 
        klass = MONKEY_MEDIA_STREAM_INFO_GET_CLASS (info);
516
 
 
517
 
        ret = klass->get_value (info, field, index, value);
518
 
 
519
 
        ret = sanitize_values (ret, info, field, value);
520
 
 
521
 
        return ret;
522
 
}
523
 
 
524
 
gboolean
525
 
monkey_media_stream_info_set_value (MonkeyMediaStreamInfo *info,
526
 
                                    MonkeyMediaStreamInfoField field,
527
 
                                    int index,
528
 
                                    const GValue *value)
529
 
{
530
 
        MonkeyMediaStreamInfoClass *klass;
531
 
 
532
 
        g_return_val_if_fail (MONKEY_MEDIA_IS_STREAM_INFO (info), FALSE);
533
 
 
534
 
        klass = MONKEY_MEDIA_STREAM_INFO_GET_CLASS (info);
535
 
 
536
 
        return klass->set_value (info, field, index, value);
537
 
}
538
 
 
539
 
static const char *genres[] =
540
 
{
541
 
        "Blues",
542
 
        "Classic Rock",
543
 
        "Country",
544
 
        "Dance",
545
 
        "Disco",
546
 
        "Funk",
547
 
        "Grunge",
548
 
        "Hip-Hop",
549
 
        "Jazz",
550
 
        "Metal",
551
 
        "New Age",
552
 
        "Oldies",
553
 
        "Other",
554
 
        "Pop",
555
 
        "R&B",
556
 
        "Rap",
557
 
        "Reggae",
558
 
        "Rock",
559
 
        "Techno",
560
 
        "Industrial",
561
 
        "Alternative",
562
 
        "Ska",
563
 
        "Death Metal",
564
 
        "Pranks",
565
 
        "Soundtrack",
566
 
        "Euro-Techno",
567
 
        "Ambient",
568
 
        "Trip-Hop",
569
 
        "Vocal",
570
 
        "Jazz+Funk",
571
 
        "Fusion",
572
 
        "Trance",
573
 
        "Classical",
574
 
        "Instrumental",
575
 
        "Acid",
576
 
        "House",
577
 
        "Game",
578
 
        "Sound Clip",
579
 
        "Gospel",
580
 
        "Noise",
581
 
        "AlternRock",
582
 
        "Bass",
583
 
        "Soul",
584
 
        "Punk",
585
 
        "Space",
586
 
        "Meditative",
587
 
        "Instrumental Pop",
588
 
        "Instrumental Rock",
589
 
        "Ethnic",
590
 
        "Gothic",
591
 
        "Darkwave",
592
 
        "Techno-Industrial",
593
 
        "Electronic",
594
 
        "Pop-Folk",
595
 
        "Eurodance",
596
 
        "Dream",
597
 
        "Southern Rock",
598
 
        "Comedy",
599
 
        "Cult",
600
 
        "Gangsta",
601
 
        "Top 40",
602
 
        "Christian Rap",
603
 
        "Pop/Funk",
604
 
        "Jungle",
605
 
        "Native American",
606
 
        "Cabaret",
607
 
        "New Wave",
608
 
        "Psychadelic",
609
 
        "Rave",
610
 
        "ShowTunes",
611
 
        "Trailer",
612
 
        "Lo-Fi",
613
 
        "Tribal",
614
 
        "Acid Punk",
615
 
        "Acid Jazz",
616
 
        "Polka",
617
 
        "Retro",
618
 
        "Musical",
619
 
        "Rock & Roll",
620
 
        "Hard Rock",
621
 
        "Folk",
622
 
        "Folk-Rock",
623
 
        "National Folk",
624
 
        "Swing",
625
 
        "Fast Fusion",
626
 
        "Bebob",
627
 
        "Latin",
628
 
        "Revival",
629
 
        "Celtic",
630
 
        "Bluegrass",
631
 
        "Avantgarde",
632
 
        "Gothic Rock",
633
 
        "Progressive Rock",
634
 
        "Psychedelic Rock",
635
 
        "Symphonic Rock",
636
 
        "Slow Rock",
637
 
        "Big Band",
638
 
        "Chorus",
639
 
        "Easy Listening",
640
 
        "Acoustic",
641
 
        "Humour",
642
 
        "Speech",
643
 
        "Chanson",
644
 
        "Opera",
645
 
        "Chamber Music",
646
 
        "Sonata",
647
 
        "Symphony",
648
 
        "Booty Bass",
649
 
        "Primus",
650
 
        "Porn Groove",
651
 
        "Satire",
652
 
        "Slow Jam",
653
 
        "Club",
654
 
        "Tango",
655
 
        "Samba",
656
 
        "Folklore",
657
 
        "Ballad",
658
 
        "Power Ballad",
659
 
        "Rhythmic Soul",
660
 
        "Freestyle",
661
 
        "Duet",
662
 
        "Punk Rock",
663
 
        "Drum Solo",
664
 
        "A Capella",
665
 
        "Euro-House",
666
 
        "Dance Hall",
667
 
        N_("Unknown")
668
 
};
669
 
 
670
 
GList *
671
 
monkey_media_stream_info_list_all_genres (void)
672
 
{
673
 
        static GList *list = NULL;
674
 
        GList *list2;
675
 
        int i;
676
 
 
677
 
        if (list != NULL)
678
 
                return list;
679
 
 
680
 
        for (i = 0; i < G_N_ELEMENTS (genres); i++)
681
 
                list = g_list_append (list, _(genres[i]));
682
 
        
683
 
        list2 = g_list_sort (list, (GCompareFunc) strcmp);
684
 
        list = list2;
685
 
 
686
 
        return list;
687
 
}
688
 
 
689
 
int
690
 
monkey_media_stream_info_genre_to_index (const char *genre)
691
 
{
692
 
        int i;
693
 
        
694
 
        for (i = 0; i < G_N_ELEMENTS (genres); i++)
695
 
        {
696
 
                if (strcmp (genre, _(genres[i])) == 0)
697
 
                        return i;
698
 
        }
699
 
 
700
 
        return G_N_ELEMENTS (genres) - 1;
701
 
}
702
 
 
703
 
const char *
704
 
monkey_media_stream_info_index_to_genre (int index)
705
 
{
706
 
        if (index >= G_N_ELEMENTS (genres))
707
 
                return _(genres[G_N_ELEMENTS (genres) - 1]);
708
 
 
709
 
        return _(genres[index]);
710
 
}
711
 
 
712
 
#ifdef HAVE_MUSICBRAINZ
713
 
static void
714
 
clear_values (MonkeyMediaStreamInfo *info,
715
 
              MonkeyMediaStreamInfoField field)
716
 
{
717
 
        int i;
718
 
        
719
 
        for (i = monkey_media_stream_info_get_n_values (info, field) - 1; i >= 0; i--)
720
 
        {
721
 
                GValue value = { 0, };
722
 
                g_value_init (&value, G_TYPE_NONE);
723
 
                monkey_media_stream_info_set_value (info, field, i, &value);
724
 
        }
725
 
}
726
 
#endif
727
 
 
728
 
gboolean
729
 
monkey_media_stream_info_get_value_net (MonkeyMediaStreamInfo *info,
730
 
                                        MonkeyMediaStreamInfoField field,
731
 
                                        GValue *value,
732
 
                                        GError **error)
733
 
{
734
 
#ifdef HAVE_MUSICBRAINZ
735
 
        MonkeyMediaMusicbrainz *mb;
736
 
        gboolean ret;
737
 
#endif
738
 
        GValue val = { 0, };
739
 
 
740
 
        g_return_val_if_fail (MONKEY_MEDIA_IS_STREAM_INFO (info), FALSE);
741
 
 
742
 
        if (monkey_media_stream_info_get_value (info,
743
 
                                                MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_TRM_ID,
744
 
                                                0,
745
 
                                                &val) == FALSE)
746
 
        {
747
 
                if (*error != NULL)
748
 
                {
749
 
                        *error = g_error_new (MONKEY_MEDIA_STREAM_INFO_ERROR,
750
 
                                              MONKEY_MEDIA_STREAM_INFO_ERROR_NO_TRM_ID,
751
 
                                              _("No TRM ID for this song"));
752
 
                }
753
 
                return FALSE;
754
 
        }
755
 
 
756
 
#ifdef HAVE_MUSICBRAINZ
757
 
        mb = monkey_media_musicbrainz_new ();
758
 
 
759
 
        if (monkey_media_musicbrainz_load_info (mb,
760
 
                                                MONKEY_MEDIA_MUSICBRAINZ_QUERY_SONG,
761
 
                                                g_value_get_string (&val)) == FALSE)
762
 
        {
763
 
                if (*error != NULL)
764
 
                {
765
 
                        *error = g_error_new (MONKEY_MEDIA_STREAM_INFO_ERROR,
766
 
                                              MONKEY_MEDIA_STREAM_INFO_ERROR_NO_NET_INFO,
767
 
                                              _("No information for this song found"));
768
 
                }
769
 
                g_value_unset (&val);
770
 
                g_object_unref (G_OBJECT (mb));
771
 
                return FALSE;
772
 
        }
773
 
 
774
 
        g_value_unset (&val);
775
 
 
776
 
        ret = monkey_media_musicbrainz_query (mb,
777
 
                                              field,
778
 
                                              -1,
779
 
                                              value);
780
 
 
781
 
        g_object_unref (G_OBJECT (mb));
782
 
        return ret;
783
 
#else
784
 
        return TRUE;
785
 
#endif
786
 
}
787
 
 
788
 
void
789
 
monkey_media_stream_info_sync_from_net (MonkeyMediaStreamInfo *info,
790
 
                                        GError **error)
791
 
{
792
 
#ifdef HAVE_MUSICBRAINZ
793
 
        MonkeyMediaMusicbrainz *mb;
794
 
        GValue value = { 0, };
795
 
        int i;
796
 
 
797
 
        static MonkeyMediaStreamInfoField sync_fields[] = {
798
 
                MONKEY_MEDIA_STREAM_INFO_FIELD_TITLE,
799
 
                MONKEY_MEDIA_STREAM_INFO_FIELD_ARTIST,
800
 
                MONKEY_MEDIA_STREAM_INFO_FIELD_ALBUM,
801
 
                MONKEY_MEDIA_STREAM_INFO_FIELD_TRACK_NUMBER,
802
 
                MONKEY_MEDIA_STREAM_INFO_FIELD_MAX_TRACK_NUMBER
803
 
        };
804
 
 
805
 
        g_return_if_fail (MONKEY_MEDIA_IS_STREAM_INFO (info));
806
 
 
807
 
        if (monkey_media_stream_info_get_value (info,
808
 
                                                MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_TRM_ID,
809
 
                                                0,
810
 
                                                &value) == FALSE)
811
 
        {
812
 
                if (*error != NULL)
813
 
                {
814
 
                        *error = g_error_new (MONKEY_MEDIA_STREAM_INFO_ERROR,
815
 
                                              MONKEY_MEDIA_STREAM_INFO_ERROR_NO_TRM_ID,
816
 
                                              _("No TRM ID for this song"));
817
 
                }
818
 
                return;
819
 
        }
820
 
 
821
 
        mb = monkey_media_musicbrainz_new ();
822
 
 
823
 
        if (monkey_media_musicbrainz_load_info (mb,
824
 
                                                MONKEY_MEDIA_MUSICBRAINZ_QUERY_SONG,
825
 
                                                g_value_get_string (&value)) == FALSE)
826
 
        {
827
 
                if (*error != NULL)
828
 
                {
829
 
                        *error = g_error_new (MONKEY_MEDIA_STREAM_INFO_ERROR,
830
 
                                              MONKEY_MEDIA_STREAM_INFO_ERROR_NO_NET_INFO,
831
 
                                              _("No information for this song found"));
832
 
                }
833
 
                g_value_unset (&value);
834
 
                g_object_unref (G_OBJECT (mb));
835
 
                return;
836
 
        }
837
 
 
838
 
        g_value_unset (&value);
839
 
 
840
 
        for (i = 0; i < G_N_ELEMENTS (sync_fields); i++)
841
 
        {
842
 
                if (monkey_media_musicbrainz_query (mb,
843
 
                                                    sync_fields[i],
844
 
                                                    -1,
845
 
                                                    &value) == TRUE)
846
 
                {
847
 
                        clear_values (info, sync_fields[i]);
848
 
                        monkey_media_stream_info_set_value (info,
849
 
                                                            sync_fields[i],
850
 
                                                            0,
851
 
                                                            &value);
852
 
                        g_value_unset (&value);
853
 
                }
854
 
        }
855
 
 
856
 
        g_object_unref (G_OBJECT (mb));
857
 
#endif
858
 
}