← Back to branch summary

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

« back to all changes in this revision

Viewing changes to metadata/rb-metadata-mm.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/rb-metadata-mm.c
1
 
/*
2
 
 *  arch-tag: Implementation of metadata reading using monkey-media
3
 
 *
4
 
 *  Copyright (C) 2003 Colin Walters <walters@verbum.org>
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
 
 *
20
 
 */
21
 
 
22
 
#include <config.h>
23
 
#include <libgnomevfs/gnome-vfs-mime-utils.h>
24
 
#include <libgnome/gnome-i18n.h>
25
 
 
26
 
#include "rb-metadata.h"
27
 
#include "rb-debug.h"
28
 
#include "monkey-media-stream-info.h"
29
 
 
30
 
static void rb_metadata_class_init (RBMetaDataClass *klass);
31
 
static void rb_metadata_init (RBMetaData *md);
32
 
static void rb_metadata_finalize (GObject *object);
33
 
 
34
 
struct RBMetaDataPrivate
35
 
{
36
 
        char *uri;
37
 
        char *type;
38
 
  
39
 
        GHashTable *metadata;
40
 
};
41
 
 
42
 
static GObjectClass *parent_class = NULL;
43
 
 
44
 
GType
45
 
rb_metadata_get_type (void)
46
 
{
47
 
        static GType type = 0;
48
 
 
49
 
        if (type == 0) {
50
 
                static const GTypeInfo our_info =
51
 
                {
52
 
                        sizeof (RBMetaDataClass),
53
 
                        NULL,
54
 
                        NULL,
55
 
                        (GClassInitFunc) rb_metadata_class_init,
56
 
                        NULL,
57
 
                        NULL,
58
 
                        sizeof (RBMetaData),
59
 
                        0,
60
 
                        (GInstanceInitFunc) rb_metadata_init,
61
 
                };
62
 
 
63
 
                type = g_type_register_static (G_TYPE_OBJECT,
64
 
                                               "RBMetaData",
65
 
                                               &our_info, 0);
66
 
        }
67
 
 
68
 
        return type;
69
 
}
70
 
 
71
 
static void
72
 
rb_metadata_class_init (RBMetaDataClass *klass)
73
 
{
74
 
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
75
 
 
76
 
        parent_class = g_type_class_peek_parent (klass);
77
 
 
78
 
        object_class->finalize = rb_metadata_finalize;
79
 
}
80
 
 
81
 
static void
82
 
rb_metadata_init (RBMetaData *md)
83
 
{
84
 
        md->priv = g_new0 (RBMetaDataPrivate, 1);
85
 
        
86
 
        md->priv->uri = NULL;
87
 
        md->priv->type = NULL;
88
 
}
89
 
 
90
 
static void
91
 
rb_metadata_finalize (GObject *object)
92
 
{
93
 
        RBMetaData *md;
94
 
 
95
 
        md = RB_METADATA (object);
96
 
 
97
 
        g_hash_table_destroy (md->priv->metadata);
98
 
 
99
 
        g_free (md->priv->type);
100
 
        g_free (md->priv->uri);
101
 
 
102
 
        g_free (md->priv);
103
 
 
104
 
        G_OBJECT_CLASS (parent_class)->finalize (object);
105
 
}
106
 
 
107
 
RBMetaData *
108
 
rb_metadata_new (void)
109
 
{
110
 
        return RB_METADATA (g_object_new (RB_TYPE_METADATA, NULL));
111
 
}
112
 
 
113
 
static void
114
 
free_gvalue (GValue *val)
115
 
{
116
 
        g_value_unset (val);
117
 
        g_free (val);
118
 
}
119
 
 
120
 
static void
121
 
load_val (RBMetaData *md,
122
 
          MonkeyMediaStreamInfo *info,
123
 
          MonkeyMediaStreamInfoField mmfield,
124
 
          RBMetaDataField mdfield)
125
 
{
126
 
        GValue *val = g_new0 (GValue, 1);
127
 
 
128
 
        if (monkey_media_stream_info_get_value (info,
129
 
                                                mmfield,
130
 
                                                0, val))          
131
 
                g_hash_table_insert (md->priv->metadata,
132
 
                                     GINT_TO_POINTER (mdfield),
133
 
                                     val);
134
 
        else
135
 
                g_free (val);
136
 
}
137
 
 
138
 
void
139
 
rb_metadata_load (RBMetaData *md,
140
 
                  const char *uri,
141
 
                  GError **error)
142
 
{
143
 
        MonkeyMediaStreamInfo *info = NULL;
144
 
 
145
 
        g_free (md->priv->uri);
146
 
        md->priv->uri = NULL;
147
 
 
148
 
        g_free (md->priv->type);
149
 
        md->priv->type = NULL;
150
 
        
151
 
        if (uri == NULL)
152
 
                return;
153
 
                
154
 
        md->priv->uri = g_strdup (uri);
155
 
        md->priv->type = gnome_vfs_get_mime_type (md->priv->uri);
156
 
 
157
 
        if (md->priv->metadata)
158
 
                g_hash_table_destroy (md->priv->metadata);
159
 
        md->priv->metadata = g_hash_table_new_full (g_direct_hash, g_direct_equal,
160
 
                                                    NULL, (GDestroyNotify) free_gvalue);
161
 
 
162
 
        info = monkey_media_stream_info_new (uri, error);
163
 
        
164
 
        if (info == NULL)
165
 
                return;
166
 
 
167
 
        load_val (md, info, MONKEY_MEDIA_STREAM_INFO_FIELD_TRACK_NUMBER,
168
 
                  RB_METADATA_FIELD_TRACK_NUMBER);
169
 
        
170
 
        load_val (md, info, MONKEY_MEDIA_STREAM_INFO_FIELD_DISC_NUMBER,
171
 
                  RB_METADATA_FIELD_DISC_NUMBER);
172
 
 
173
 
        /* duration */
174
 
        load_val (md, info,
175
 
                  MONKEY_MEDIA_STREAM_INFO_FIELD_DURATION,
176
 
                  RB_METADATA_FIELD_DURATION);
177
 
 
178
 
        /* quality */
179
 
        load_val (md, info,
180
 
                  MONKEY_MEDIA_STREAM_INFO_FIELD_AUDIO_BIT_RATE,
181
 
                  RB_METADATA_FIELD_BITRATE);
182
 
 
183
 
        /* title */
184
 
        load_val (md, info,
185
 
                  MONKEY_MEDIA_STREAM_INFO_FIELD_TITLE,
186
 
                  RB_METADATA_FIELD_TITLE);
187
 
 
188
 
        /* genre */
189
 
        load_val (md, info,
190
 
                  MONKEY_MEDIA_STREAM_INFO_FIELD_GENRE,
191
 
                  RB_METADATA_FIELD_GENRE);
192
 
 
193
 
        /* artist */
194
 
        load_val (md, info,
195
 
                  MONKEY_MEDIA_STREAM_INFO_FIELD_ARTIST,
196
 
                  RB_METADATA_FIELD_ARTIST);
197
 
 
198
 
        /* album */
199
 
        load_val (md, info,
200
 
                  MONKEY_MEDIA_STREAM_INFO_FIELD_ALBUM,
201
 
                  RB_METADATA_FIELD_ALBUM);
202
 
 
203
 
        g_object_unref (G_OBJECT (info));
204
 
 
205
 
}
206
 
 
207
 
gboolean
208
 
rb_metadata_can_save (RBMetaData *md, const char *mimetype)
209
 
{
210
 
        return FALSE;
211
 
}
212
 
 
213
 
void
214
 
rb_metadata_save (RBMetaData *md, GError **error)
215
 
{
216
 
        g_set_error (error,
217
 
                     RB_METADATA_ERROR,
218
 
                     RB_METADATA_ERROR_UNSUPPORTED,
219
 
                     _("Operation not supported"));
220
 
}
221
 
 
222
 
gboolean
223
 
rb_metadata_get (RBMetaData *md, RBMetaDataField field,
224
 
                 GValue *ret)
225
 
{
226
 
        GValue *val;
227
 
        if ((val = g_hash_table_lookup (md->priv->metadata,
228
 
                                        GINT_TO_POINTER (field)))) {
229
 
                g_value_init (ret, G_VALUE_TYPE (val));
230
 
                g_value_copy (val, ret);
231
 
                return TRUE;
232
 
        }
233
 
        return FALSE;
234
 
}
235
 
 
236
 
gboolean
237
 
rb_metadata_set (RBMetaData *md, RBMetaDataField field,
238
 
                 const GValue *val)
239
 
{
240
 
        return FALSE;
241
 
}
242
 
 
243
 
const char *
244
 
rb_metadata_get_mime (RBMetaData *md)
245
 
{
246
 
        return (md->priv->type);
247
 
}