src/plugin.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <gtk/gtk.h>
   4 #include <libxml/parser.h>
   5 #include <libxml/tree.h>
   6 #include <libmpd/debug_printf.h>
   7 #include <gmpc/plugin.h>
   8 #include <gmpc/gmpc_easy_download.h>
   9 #include <config.h>
  10 #define AMAZONKEY "14TC04B24356BPHXW1R2"
  11
  12 static char * host = "http://ecs.amazonaws.%s/onca/xml?Service=AWSECommerceService&Operation=ItemSearch&SearchIndex=Music&ResponseGroup=Images,EditorialReview&AWSAccessKeyId=%s&%s=%s&%s=%s";
  13
  14 static int fetch_cover_art(mpd_Song *song,int type, char **url);
  15
  16 #define ENDPOINTS 6
  17 static char *endpoints[ENDPOINTS][2] =
  18 {
  19         {"com",         "United States"},
  20         {"co.uk",       "United Kingdom"},
  21         {"jp",          "Japan"},
  22         {"fr",          "France"},
  23         {"ca",          "Canada"},
  24         {"de",          "Germany"}
  25 };
  26
  27 static GtkWidget *wp_pref_vbox = NULL;
  28
  29 typedef struct amazon_song_info {
  30         char *image_big;
  31         char *image_medium;
  32         char *image_small;
  33         char *album_info;
  34
  35 }amazon_song_info;
  36
  37 /**
  38  * Get Set enabled
  39  */
  40 static int amazon_get_enabled()
  41 {
  42         return cfg_get_single_value_as_int_with_default(config, "cover-amazon", "enable", TRUE);
  43 }
  44 static void amazon_set_enabled(int enabled)
  45 {
  46         cfg_set_single_value_as_int(config, "cover-amazon", "enable", enabled);
  47 }
  48
  49 /**
  50  * Get priority
  51  */
  52 static int fetch_cover_priority(){
  53         return cfg_get_single_value_as_int_with_default(config, "cover-amazon", "priority", 80);
  54 }
  55
  56 static int fetch_metadata(mpd_Song *song,MetaDataType type, char **path)
  57 {
  58         gchar *url = NULL;
  59
  60         if(song->artist == NULL || song->album == NULL)
  61         {
  62                 return META_DATA_UNAVAILABLE;
  63         }
  64         if(type != META_ALBUM_ART && type != META_ALBUM_TXT) {
  65                 return META_DATA_UNAVAILABLE;
  66         }
  67         /* Always fetch it. */
  68         fetch_cover_art(song,type, &url);
  69         if(url){
  70                 *path = url;
  71                 return META_DATA_AVAILABLE;
  72         }
  73
  74         g_free(url);
  75         return META_DATA_UNAVAILABLE;
  76 }
  77
  78 static amazon_song_info * amazon_song_info_new()
  79 {
  80         amazon_song_info *asi = g_malloc(sizeof(amazon_song_info));
  81         asi->image_big = NULL;
  82         asi->image_medium = NULL;
  83         asi->image_small = NULL;
  84         asi->album_info = NULL;
  85         return asi;
  86 }
  87 static void amazon_song_info_free(amazon_song_info *asi)
  88 {
  89         if(asi->image_big != NULL) g_free(asi->image_big);
  90         if(asi->image_medium != NULL) g_free(asi->image_medium);
  91         if(asi->image_small != NULL) g_free(asi->image_small);
  92         if(asi->album_info != NULL) g_free(asi->album_info);
  93         g_free(asi);
  94         return;
  95 }
  96
  97 static xmlNodePtr get_first_node_by_name(xmlNodePtr xml, gchar *name) {
  98         if(xml) {
  99                 xmlNodePtr c = xml->xmlChildrenNode;
 100                 for(;c;c=c->next) {
 101                         if(xmlStrEqual(c->name, (xmlChar *) name))
 102                                 return c;
 103                 }
 104         }
 105         return NULL;
 106 }
 107
 108 static amazon_song_info *__cover_art_xml_get_image(char *data,int size)
 109 {
 110         xmlDocPtr doc = xmlParseMemory(data,size);
 111         if(doc)
 112         {
 113                 xmlNodePtr root = xmlDocGetRootElement(doc);
 114                 xmlNodePtr cur = get_first_node_by_name(root, "Items");
 115                 amazon_song_info *asi = NULL;
 116                 if(cur) {
 117                         cur = get_first_node_by_name(cur, "Item");
 118                         if(cur) {
 119                                 xmlNodePtr child = NULL;
 120                                 asi = amazon_song_info_new();
 121                                 if((child = get_first_node_by_name(cur, "LargeImage"))) {
 122                                         xmlChar *temp = xmlNodeGetContent(get_first_node_by_name(child, "URL"));
 123                                         /* copy it, so we can free it, and don't need xmlFree */
 124                                         asi->image_big = g_strdup((char *)temp);
 125                                         xmlFree(temp);
 126                                 }
 127                                 if((child = get_first_node_by_name(cur, "MediumImage"))){
 128                                         xmlChar *temp = xmlNodeGetContent(get_first_node_by_name(child, "URL"));
 129                                         asi->image_medium = g_strdup((char *)temp);
 130                                         xmlFree(temp);
 131                                 }
 132                                 if((child = get_first_node_by_name(cur, "SmallImage"))){
 133                                         xmlChar *temp = xmlNodeGetContent(get_first_node_by_name(child, "URL"));
 134                                         asi->image_small = g_strdup((char *)temp);
 135                                         xmlFree(temp);
 136                                 }
 137
 138                                 if((child = get_first_node_by_name(cur, "EditorialReviews"))) {
 139                                         child = get_first_node_by_name(child, "EditorialReview");
 140                                         if(child) {
 141                                                 xmlChar *temp = xmlNodeGetContent(get_first_node_by_name(child, "Content")); /* ugy, lazy */
 142                                                 asi->album_info = g_strdup((char *)temp);
 143                                                 xmlFree(temp);
 144                                         }
 145                                 }
 146                         }
 147                 }
 148                 xmlFreeDoc(doc);
 149                 return asi;
 150         }
 151         xmlCleanupParser();
 152         return NULL;
 153 }
 154
 155
 156 static int __fetch_metadata_amazon(char *sfield, char *nartist, char *stype,char *nalbum,int type, char **url)
 157 {
 158
 159         gmpc_easy_download_struct data= {NULL, 0,-1, NULL, NULL};
 160         int found = 0;
 161         char furl[1024];
 162         int endpoint = cfg_get_single_value_as_int_with_default(config, "cover-amazon", "location", 0);
 163         char *endp = endpoints[endpoint][0];
 164
 165         debug_printf(DEBUG_INFO, "search-type: %s\n", stype);
 166         snprintf(furl,1024, host,endp, AMAZONKEY,sfield, nartist, stype, nalbum);
 167         if(gmpc_easy_download(furl, &data))
 168         {
 169                 amazon_song_info *asi = __cover_art_xml_get_image(data.data, data.size);
 170                 gmpc_easy_download_clean(&data);
 171                 if(asi)
 172                 {
 173                         if(type&META_ALBUM_ART)
 174                         {
 175                                 debug_printf(DEBUG_INFO, "Trying to fetch album art");
 176                                 gmpc_easy_download(asi->image_big, &data);
 177                                 if(data.size <= 900){
 178                                         gmpc_easy_download_clean(&data);
 179                                         gmpc_easy_download(asi->image_medium, &data);
 180                                         if(data.size <= 900){
 181                                                 gmpc_easy_download_clean(&data);
 182                                                 gmpc_easy_download(asi->image_small, &data);
 183                                                 if(data.size <= 900)
 184                                                 {
 185                                                         gmpc_easy_download_clean(&data);
 186                                                 }
 187                                         }
 188                                 }
 189                                 if(data.size){
 190                                         FILE *fp = NULL;
 191                                         gchar *imgpath = NULL;
 192                                         gchar *filename = g_strdup_printf("%s-%s.jpg",nartist,nalbum);
 193                                         imgpath =  gmpc_get_covers_path(filename);
 194                                         g_free(filename);
 195                                         fp = fopen(imgpath, "wb");
 196                                         if(fp)
 197                                         {
 198                                                 fwrite(data.data, sizeof(char), data.size,fp);
 199                                                 *url = g_strdup(imgpath);
 200                                                 found = 1;
 201                                                 fclose(fp);
 202                                         }
 203                                         g_free(imgpath);
 204                                 }
 205                                 gmpc_easy_download_clean(&data);
 206
 207
 208                         }
 209                         else if(type&META_ALBUM_TXT)
 210                         {
 211                                 debug_printf(DEBUG_INFO, "Trying to fetch album txt");
 212                                 if(asi->album_info)
 213                                 {
 214                                         FILE *fp;
 215                                         gchar *filename, *imgpath;
 216                                         filename = g_strdup_printf("%s-%s.albuminfo",nartist,nalbum);
 217                                         imgpath =  gmpc_get_covers_path(filename);
 218                                         g_free(filename);
 219                                         fp = fopen(imgpath, "w");
 220                                         if(fp)
 221                                         {
 222                                                 int j=0,depth=0;;
 223                                                 *url = g_strdup(imgpath);
 224                                                 /**
 225                                                  * Quick 'n Dirty html stripper
 226                                                  */
 227                                                 for(j=0; j < strlen(asi->album_info);j++)
 228                                                 {
 229                                                         if((asi->album_info)[j]  == '<') depth++;
 230                                                         else if((asi->album_info)[j] == '>' && depth) depth--;
 231                                                         else if(depth == 0)
 232                                                         {
 233                                                                 fputc((asi->album_info)[j],fp);
 234                                                         }
 235                                                 }
 236                                                 fclose(fp);
 237                                                 found = 1;
 238                                         }
 239
 240                                         g_free(imgpath);
 241                                 }
 242                         }
 243                         amazon_song_info_free(asi);
 244                 }
 245         }
 246
 247         return found;
 248 }
 249 static int fetch_cover_art(mpd_Song *song,int type, char **url)
 250 {
 251         int retval=0;
 252         gchar *artist = g_uri_escape_string(song->artist,NULL, TRUE);
 253         gchar *album =  g_uri_escape_string(song->album,NULL, TRUE);
 254
 255     retval = __fetch_metadata_amazon(
 256                 "Title",album,
 257                 "Artist", artist,
 258                 type,url);
 259     if(!retval && song->performer)
 260     {
 261         gchar *performer = g_uri_escape_string(song->performer, NULL, TRUE);
 262         retval = __fetch_metadata_amazon(
 263                 "Title",album,
 264             "Performer", performer,
 265             type,url);
 266         g_free(performer);
 267     }
 268
 269         g_free(artist);
 270         g_free(album);
 271         return retval;
 272 }
 273
 274 /**
 275  * Preferences
 276  */
 277
 278 static void amazon_cover_art_enable_toggle(GtkWidget *wid)
 279 {
 280         int kk = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wid));
 281         amazon_set_enabled(kk);
 282 }
 283 static void amazon_cover_art_pref_destroy(GtkWidget *container)
 284 {
 285         gtk_container_remove(GTK_CONTAINER(container), wp_pref_vbox);
 286 }
 287 static void amazon_cover_art_pref_selection_changed(GtkWidget *box)
 288 {
 289         cfg_set_single_value_as_int(config, "cover-amazon", "location", gtk_combo_box_get_active(GTK_COMBO_BOX(box)));
 290 }
 291
 292 static void amazon_cover_art_pref_construct(GtkWidget *container)
 293 {
 294         GtkWidget *enable_cg = gtk_check_button_new_with_mnemonic("_Enable amazon as cover art source");
 295         GtkWidget *label = NULL;
 296         GtkWidget *selection = NULL;
 297         GtkWidget *hbox = NULL;
 298         int i;
 299         wp_pref_vbox = gtk_vbox_new(FALSE,6);
 300
 301         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_cg), amazon_get_enabled());
 302
 303         g_signal_connect(G_OBJECT(enable_cg), "toggled", G_CALLBACK(amazon_cover_art_enable_toggle), NULL);
 304         gtk_box_pack_start(GTK_BOX(wp_pref_vbox), enable_cg, FALSE, FALSE, 0);
 305
 306         /* Location */
 307         hbox = gtk_hbox_new(FALSE, 6);
 308         label = gtk_label_new("Location:");
 309         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE,0);
 310         selection = gtk_combo_box_new_text();
 311         for(i=0;i<ENDPOINTS;i++)
 312                 gtk_combo_box_append_text(GTK_COMBO_BOX(selection), endpoints[i][1]);
 313         gtk_combo_box_set_active(GTK_COMBO_BOX(selection),cfg_get_single_value_as_int_with_default(config, "cover-amazon", "location", 0));
 314         g_signal_connect(G_OBJECT(selection), "changed",G_CALLBACK(amazon_cover_art_pref_selection_changed), NULL);
 315
 316         gtk_box_pack_start(GTK_BOX(hbox), selection, TRUE,TRUE,0);
 317         gtk_box_pack_start(GTK_BOX(wp_pref_vbox), hbox, FALSE, FALSE, 0);
 318
 319         gtk_container_add(GTK_CONTAINER(container), wp_pref_vbox);
 320         gtk_widget_show_all(container);
 321 }
 322
 323 gmpcPrefPlugin cam_pref = {
 324         .construct      = amazon_cover_art_pref_construct,
 325         .destroy        = amazon_cover_art_pref_destroy
 326
 327 };
 328 gmpcMetaDataPlugin cam_cover = {
 329         .get_priority   = fetch_cover_priority,
 330         .get_image      = fetch_metadata
 331 };
 332
 333 int plugin_api_version = PLUGIN_API_VERSION;
 334 gmpcPlugin plugin = {
 335         .name           = "Amazon Cover Fetcher",
 336         .version        = {PLUGIN_MAJOR_VERSION,PLUGIN_MINOR_VERSION,PLUGIN_MICRO_VERSION},
 337         .plugin_type    = GMPC_PLUGIN_META_DATA,
 338         .pref           = &cam_pref,
 339         .metadata       = &cam_cover,
 340         .get_enabled    = amazon_get_enabled,
 341         .set_enabled    = amazon_set_enabled
 342 };