metadata/sj-metadata-musicbrainz.c

   1 /*
   2  * sj-metadata-musicbrainz.c
   3  * Copyright (C) 2003 Ross Burton <ross@burtonini.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <string.h>
  22 #include <glib-object.h>
  23 #include <glib/gi18n.h>
  24 #include <glib/gerror.h>
  25 #include <glib/glist.h>
  26 #include <glib/gstrfuncs.h>
  27 #include <glib/gmessages.h>
  28 #include <musicbrainz/queries.h>
  29 #include <musicbrainz/mb_c.h>
  30 #include <nautilus-burn-drive.h>
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <stdio.h>
  34
  35 #include "eel-gconf-extensions.h"
  36 #include "sj-metadata-musicbrainz.h"
  37 #include "sj-structures.h"
  38 #include "sj-error.h"
  39
  40
  41 #define GCONF_MUSICBRAINZ_SERVER "/apps/sound-juicer" "/musicbrainz_server"
  42
  43
  44 struct SjMetadataMusicbrainzPrivate {
  45   GError *construct_error;
  46   musicbrainz_t mb;
  47   char *http_proxy;
  48   int http_proxy_port;
  49   char *cdrom;
  50   /* TODO: remove and use an async queue or something l33t */
  51   GList *albums;
  52   GError *error;
  53 };
  54
  55 static GError* mb_get_new_error (SjMetadata *metadata);
  56 static void mb_set_cdrom (SjMetadata *metadata, const char* device);
  57 static void mb_set_proxy (SjMetadata *metadata, const char* proxy);
  58 static void mb_set_proxy_port (SjMetadata *metadata, const int port);
  59 static void mb_list_albums (SjMetadata *metadata, GError **error);
  60
  61 /**
  62  * GObject methods
  63  */
  64
  65 static GObjectClass *parent_class = NULL;
  66
  67 static void
  68 sj_metadata_musicbrainz_finalize (GObject *object)
  69 {
  70   SjMetadataMusicbrainzPrivate *priv;
  71   g_return_if_fail (object != NULL);
  72   priv = SJ_METADATA_MUSICBRAINZ (object)->priv;
  73
  74   g_free (priv->http_proxy);
  75   g_free (priv->cdrom);
  76   mb_Delete (priv->mb);
  77   g_free (priv);
  78 }
  79
  80 static void
  81 sj_metadata_musicbrainz_instance_init (GTypeInstance *instance, gpointer g_class)
  82 {
  83   char *server_name = NULL;
  84   SjMetadataMusicbrainz *self = (SjMetadataMusicbrainz*)instance;
  85   self->priv = g_new0 (SjMetadataMusicbrainzPrivate, 1);
  86   self->priv->construct_error = NULL;
  87   self->priv->mb = mb_New ();
  88   /* TODO: something. :/ */
  89   if (!self->priv->mb) {
  90     g_set_error (&self->priv->construct_error,
  91                  SJ_ERROR, SJ_ERROR_CD_LOOKUP_ERROR,
  92                  _("Cannot create MusicBrainz client"));
  93     return;
  94   }
  95   mb_UseUTF8 (self->priv->mb, TRUE);
  96
  97   server_name = eel_gconf_get_string (GCONF_MUSICBRAINZ_SERVER);
  98   if (server_name) {
  99     g_strstrip (server_name);
 100   }
 101   if (server_name && strcmp (server_name, "") != 0) {
 102     mb_SetServer (self->priv->mb, server_name, 80);
 103     g_free (server_name);
 104   }
 105
 106   /* TODO: optimal setting? mb_SetDepth (self->priv->mb, 1); */
 107   if (g_getenv("MUSICBRAINZ_DEBUG")) {
 108     mb_SetDebug (self->priv->mb, TRUE);
 109   }
 110 }
 111
 112 static void
 113 metadata_interface_init (gpointer g_iface, gpointer iface_data)
 114 {
 115   SjMetadataClass *klass = (SjMetadataClass*)g_iface;
 116   klass->get_new_error = mb_get_new_error;
 117   klass->set_cdrom = mb_set_cdrom;
 118   klass->set_proxy = mb_set_proxy;
 119   klass->set_proxy_port = mb_set_proxy_port;
 120   klass->list_albums = mb_list_albums;
 121 }
 122
 123 static void
 124 sj_metadata_musicbrainz_class_init (SjMetadataMusicbrainzClass *class)
 125 {
 126   GObjectClass *object_class;
 127   parent_class = g_type_class_peek_parent (class);
 128   object_class = (GObjectClass*) class;
 129   object_class->finalize = sj_metadata_musicbrainz_finalize;
 130 }
 131
 132 GType
 133 sj_metadata_musicbrainz_get_type (void)
 134 {
 135   static GType type = 0;
 136   if (type == 0) {
 137     static const GTypeInfo info = {
 138       sizeof (SjMetadataMusicbrainzClass),
 139       NULL,
 140       NULL,
 141       (GClassInitFunc)sj_metadata_musicbrainz_class_init,
 142       NULL,
 143       NULL,
 144       sizeof (SjMetadataMusicbrainz),
 145       0,
 146       sj_metadata_musicbrainz_instance_init,
 147       NULL
 148     };
 149     static const GInterfaceInfo metadata_i_info = {
 150       (GInterfaceInitFunc) metadata_interface_init,
 151       NULL, NULL
 152     };
 153     type = g_type_register_static (G_TYPE_OBJECT, "SjMetadataMusicBrainzClass", &info, 0);
 154     g_type_add_interface_static (type, SJ_TYPE_METADATA, &metadata_i_info);
 155   }
 156   return type;
 157 }
 158
 159 GObject *
 160 sj_metadata_musicbrainz_new (void)
 161 {
 162   return g_object_new (sj_metadata_musicbrainz_get_type (), NULL);
 163 }
 164
 165 /**
 166  * Private methods
 167  */
 168
 169 #define BYTES_PER_SECTOR 2352
 170 #define BYTES_PER_SECOND (44100 / 8) / 16 / 2
 171
 172 static int
 173 get_duration_from_sectors (int sectors)
 174 {
 175   return (sectors * BYTES_PER_SECTOR / BYTES_PER_SECOND);
 176 }
 177
 178 static GList*
 179 get_offline_track_listing(SjMetadata *metadata, GError **error)
 180 {
 181   SjMetadataMusicbrainzPrivate *priv;
 182   GList* list = NULL;
 183   AlbumDetails *album;
 184   TrackDetails *track;
 185   int num_tracks, i;
 186
 187   g_return_val_if_fail (metadata != NULL, NULL);
 188   priv = SJ_METADATA_MUSICBRAINZ (metadata)->priv;
 189
 190   if (!mb_Query (priv->mb, MBQ_GetCDTOC)) {
 191     char message[255];
 192     mb_GetQueryError (priv->mb, message, 255);
 193     g_set_error (error,
 194                  SJ_ERROR, SJ_ERROR_CD_LOOKUP_ERROR,
 195                  _("Cannot read CD: %s"), message);
 196     return NULL;
 197   }
 198
 199   num_tracks = mb_GetResultInt (priv->mb, MBE_TOCGetLastTrack);
 200
 201   album = g_new0 (AlbumDetails, 1);
 202   album->artist = g_strdup (_("Unknown Artist"));
 203   album->title = g_strdup (_("Unknown Title"));
 204   album->genre = NULL;
 205   for (i = 1; i <= num_tracks; i++) {
 206     track = g_new0 (TrackDetails, 1);
 207     track->album = album;
 208     track->number = i;
 209     track->title = g_strdup_printf (_("Track %d"), i);
 210     track->artist = g_strdup (album->artist);
 211     track->duration = get_duration_from_sectors (mb_GetResultInt1 (priv->mb, MBE_TOCGetTrackNumSectors, i+1));
 212     album->tracks = g_list_prepend (album->tracks, track);
 213     album->number++;
 214   }
 215   album->tracks = g_list_reverse (album->tracks);
 216
 217   return g_list_append (list, album);
 218 }
 219
 220 static gboolean
 221 fire_signal_idle (SjMetadataMusicbrainz *m)
 222 {
 223   g_return_val_if_fail (SJ_IS_METADATA_MUSICBRAINZ (m), FALSE);
 224   g_signal_emit_by_name (G_OBJECT (m), "metadata", m->priv->albums, m->priv->error);
 225   return FALSE;
 226 }
 227
 228 /**
 229  * Virtual methods
 230  */
 231
 232 static GError*
 233 mb_get_new_error (SjMetadata *metadata)
 234 {
 235   GError *error = NULL;
 236   if (metadata == NULL || SJ_METADATA_MUSICBRAINZ (metadata)->priv == NULL) {
 237     g_set_error (&error,
 238                  SJ_ERROR, SJ_ERROR_INTERNAL_ERROR,
 239                  _("MusicBrainz metadata object is not valid. This is bad, check your console for errors."));
 240     return error;
 241   }
 242   return SJ_METADATA_MUSICBRAINZ (metadata)->priv->construct_error;
 243 }
 244
 245 static void
 246 mb_set_cdrom (SjMetadata *metadata, const char* device)
 247 {
 248   SjMetadataMusicbrainzPrivate *priv;
 249   g_return_if_fail (metadata != NULL);
 250   g_return_if_fail (device != NULL);
 251   priv = SJ_METADATA_MUSICBRAINZ (metadata)->priv;
 252
 253   if (priv->cdrom) {
 254     g_free (priv->cdrom);
 255   }
 256   priv->cdrom = g_strdup (device);
 257   mb_SetDevice (priv->mb, priv->cdrom);
 258 }
 259
 260 static void
 261 mb_set_proxy (SjMetadata *metadata, const char* proxy)
 262 {
 263   SjMetadataMusicbrainzPrivate *priv;
 264   g_return_if_fail (metadata != NULL);
 265   priv = SJ_METADATA_MUSICBRAINZ (metadata)->priv;
 266
 267   if (proxy == NULL) {
 268     proxy = "";
 269   }
 270   if (priv->http_proxy) {
 271     g_free (priv->http_proxy);
 272   }
 273   priv->http_proxy = g_strdup (proxy);
 274   mb_SetProxy (priv->mb, priv->http_proxy, priv->http_proxy_port);
 275 }
 276
 277 static void
 278 mb_set_proxy_port (SjMetadata *metadata, const int port)
 279 {
 280   SjMetadataMusicbrainzPrivate *priv;
 281   g_return_if_fail (metadata != NULL);
 282   priv = SJ_METADATA_MUSICBRAINZ (metadata)->priv;
 283
 284   priv->http_proxy_port = port;
 285   mb_SetProxy (priv->mb, priv->http_proxy, priv->http_proxy_port);
 286 }
 287
 288 static gpointer
 289 lookup_cd (SjMetadata *metadata)
 290 {
 291   /** The size of the buffer used in MusicBrainz lookups */
 292 #define MB_BUFFER_SIZE 256
 293   SjMetadataMusicbrainzPrivate *priv;
 294   GList *albums = NULL;
 295   GList *al, *tl;
 296   char data[MB_BUFFER_SIZE];
 297   int num_albums, i, j;
 298   NautilusBurnMediaType type;
 299
 300   /* TODO: fire error signal */
 301   g_return_val_if_fail (metadata != NULL, NULL);
 302   g_return_val_if_fail (SJ_IS_METADATA_MUSICBRAINZ (metadata), NULL);
 303   priv = SJ_METADATA_MUSICBRAINZ (metadata)->priv;
 304   g_return_val_if_fail (priv->cdrom != NULL, NULL);
 305   priv->error = NULL; /* TODO: hack */
 306
 307   type = nautilus_burn_drive_get_media_type_from_path (priv->cdrom);
 308   if (type == NAUTILUS_BURN_MEDIA_TYPE_ERROR) {
 309     char *msg;
 310     SjError err;
 311
 312     if (access (priv->cdrom, W_OK) == 0) {
 313       msg = g_strdup_printf (_("Device '%s' does not contain any media"), priv->cdrom);
 314       err = SJ_ERROR_CD_NO_MEDIA;
 315     } else {
 316       msg = g_strdup_printf (_("Device '%s' could not be opened. Check the access permissions on the device."), priv->cdrom);
 317       err = SJ_ERROR_CD_PERMISSION_ERROR;
 318     }
 319     priv->error = g_error_new (SJ_ERROR, err, _("Cannot read CD: %s"), msg);
 320     g_free (msg);
 321
 322     priv->albums = NULL;
 323     g_idle_add ((GSourceFunc)fire_signal_idle, metadata);
 324     return NULL;
 325   }
 326
 327   if (!mb_Query (priv->mb, MBQ_GetCDInfo)) {
 328     mb_GetQueryError (priv->mb, data, MB_BUFFER_SIZE);
 329     g_print (_("This CD could not be queried: %s\n"), data);
 330     priv->albums = get_offline_track_listing (metadata, &(priv->error));
 331     g_idle_add ((GSourceFunc)fire_signal_idle, metadata);
 332     return priv->albums;
 333   }
 334
 335   num_albums = mb_GetResultInt(priv->mb, MBE_GetNumAlbums);
 336   if (num_albums < 1) {
 337     g_print (_("This CD was not found.\n"));
 338     priv->albums = get_offline_track_listing (metadata, &(priv->error));
 339     g_idle_add ((GSourceFunc)fire_signal_idle, metadata);
 340     return priv->albums;
 341   }
 342
 343   for (i = 1; i <= num_albums; i++) {
 344     int num_tracks;
 345     AlbumDetails *album;
 346
 347     mb_Select1(priv->mb, MBS_SelectAlbum, i);
 348     album = g_new0 (AlbumDetails, 1);
 349
 350     if (mb_GetResultData(priv->mb, MBE_AlbumGetAlbumId, data, MB_BUFFER_SIZE)) {
 351       mb_GetIDFromURL (priv->mb, data, data, MB_BUFFER_SIZE);
 352       album->album_id = g_strdup (data);
 353     }
 354
 355     if (mb_GetResultData (priv->mb, MBE_AlbumGetAlbumArtistId, data, MB_BUFFER_SIZE)) {
 356       mb_GetIDFromURL (priv->mb, data, data, MB_BUFFER_SIZE);
 357       album->artist_id = g_strdup (data);
 358       if (g_ascii_strncasecmp (MBI_VARIOUS_ARTIST_ID, data, 64) == 0) {
 359         album->artist = g_strdup (_("Various"));
 360       } else {
 361         if (data && mb_GetResultData1(priv->mb, MBE_AlbumGetArtistName, data, MB_BUFFER_SIZE, 1)) {
 362           album->artist = g_strdup (data);
 363         } else {
 364           album->artist = g_strdup (_("Unknown Artist"));
 365         }
 366       }
 367     }
 368
 369     if (mb_GetResultData(priv->mb, MBE_AlbumGetAlbumName, data, MB_BUFFER_SIZE)) {
 370       album->title = g_strdup (data);
 371     } else {
 372       album->title = g_strdup (_("Unknown Title"));
 373     }
 374
 375     {
 376       int num_releases;
 377       num_releases = mb_GetResultInt (priv->mb, MBE_AlbumGetNumReleaseDates);
 378       if (num_releases > 0) {
 379         mb_Select1(priv->mb, MBS_SelectReleaseDate, 1);
 380         if (mb_GetResultData(priv->mb, MBE_ReleaseGetDate, data, MB_BUFFER_SIZE)) {
 381           int matched, year=1, month=1, day=1;
 382           matched = sscanf(data, "%u-%u-%u", &year, &month, &day);
 383           if (matched > 1) {
 384             album->release_date = g_date_new_dmy (day, month, year);
 385           }
 386         }
 387         mb_Select(priv->mb, MBS_Back);
 388       }
 389     }
 390
 391     num_tracks = mb_GetResultInt(priv->mb, MBE_AlbumGetNumTracks);
 392     if (num_tracks < 1) {
 393       g_free (album->artist);
 394       g_free (album->title);
 395       g_free (album);
 396       g_print (_("Incomplete metadata for this CD.\n"));
 397       priv->albums = get_offline_track_listing (metadata, &(priv->error));
 398       g_idle_add ((GSourceFunc)fire_signal_idle, metadata);
 399       return priv->albums;
 400     }
 401
 402     for (j = 1; j <= num_tracks; j++) {
 403       TrackDetails *track;
 404       track = g_new0 (TrackDetails, 1);
 405
 406       track->album = album;
 407
 408       track->number = j; /* replace with number lookup? */
 409
 410       if (mb_GetResultData1(priv->mb, MBE_AlbumGetTrackId, data, MB_BUFFER_SIZE, j)) {
 411         mb_GetIDFromURL (priv->mb, data, data, MB_BUFFER_SIZE);
 412         track->track_id = g_strdup (data);
 413       }
 414
 415       if (mb_GetResultData1(priv->mb, MBE_AlbumGetArtistId, data, MB_BUFFER_SIZE, j)) {
 416         mb_GetIDFromURL (priv->mb, data, data, MB_BUFFER_SIZE);
 417         track->artist_id = g_strdup (data);
 418       }
 419
 420       if (mb_GetResultData1(priv->mb, MBE_AlbumGetTrackName, data, MB_BUFFER_SIZE, j)) {
 421         track->title = g_strdup (data);
 422       }
 423
 424       if (mb_GetResultData1(priv->mb, MBE_AlbumGetArtistName, data, MB_BUFFER_SIZE, j)) {
 425         track->artist = g_strdup (data);
 426       }
 427
 428       if (mb_GetResultData1(priv->mb, MBE_AlbumGetTrackDuration, data, MB_BUFFER_SIZE, j)) {
 429         track->duration = atoi (data) / 1000;
 430       }
 431
 432       album->tracks = g_list_prepend (album->tracks, track);
 433       album->number++;
 434     }
 435     album->tracks = g_list_reverse (album->tracks);
 436
 437     albums = g_list_append (albums, album);
 438   }
 439
 440   /* For each album, we need to insert the duration data if necessary
 441    * We need to query this here because otherwise we would flush the
 442    * data queried from the server */
 443   mb_Query (priv->mb, MBQ_GetCDTOC);
 444   for (al = albums; al; al = al->next) {
 445     AlbumDetails *album = al->data;
 446
 447     j = 1;
 448     for (tl = album->tracks; tl; tl = tl->next) {
 449       TrackDetails *track = tl->data;
 450       int sectors;
 451
 452       if (track->duration == 0) {
 453         sectors = mb_GetResultInt1 (priv->mb, MBE_TOCGetTrackNumSectors, j+1);
 454         track->duration = get_duration_from_sectors (sectors);
 455       }
 456       j++;
 457     }
 458   }
 459   priv->albums = albums;
 460   g_idle_add ((GSourceFunc)fire_signal_idle, metadata);
 461   return albums;
 462 }
 463
 464 static void
 465 mb_list_albums (SjMetadata *metadata, GError **error)
 466 {
 467   GThread *thread;
 468
 469   g_return_if_fail (SJ_IS_METADATA_MUSICBRAINZ (metadata));
 470
 471   thread = g_thread_create ((GThreadFunc)lookup_cd, metadata, TRUE, error);
 472   if (thread == NULL) {
 473     g_set_error (error,
 474                  SJ_ERROR, SJ_ERROR_INTERNAL_ERROR,
 475                  _("Could not create CD lookup thread"));
 476     return;
 477   }
 478 }