library.c

   1 /*
   2  * Copyright (C) 2008 Mark Hills <mark@pogo.org.uk>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11  * General Public License version 2 for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * version 2 along with this program; if not, write to the Free
  15  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  16  * MA 02110-1301, USA.
  17  *
  18  */
  19
  20 #include <ctype.h>
  21 #include <dirent.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/stat.h>
  27 #include <sys/types.h>
  28
  29 #include "library.h"
  30 #include "record.h"
  31
  32 /*
  33 #define BLOCK 256 // number of library entries
  34
  35 #define MIN(a, b) (a<b?a:b)
  36 */
  37
  38 static int strmatch(char *little, char *big)
  39 {
  40     size_t n, m, match, little_len;
  41
  42     little_len = strlen(little);
  43
  44     for(n = 0; n + little_len <= strlen(big); n++) {
  45
  46         match = 1;
  47
  48         for(m = 0; m < little_len; m++) {
  49             if(tolower(little[m]) != tolower(big[n + m])) {
  50                 match = 0;
  51                 break;
  52             }
  53         }
  54
  55         if(match)
  56             return 1;
  57     }
  58
  59     return 0;
  60 }
  61
  62 /* Copy src (ms characters) to dest (length md, including '\0'), and
  63  * ensure the result is safe and null terminated */
  64
  65 /*
  66 static int strmcpy(char *dest, int md, char *src, int ms)
  67 {
  68     strncpy(dest, src, MIN(ms, md));
  69     if(ms < md)
  70         dest[ms] = '\0';
  71     else
  72         dest[md - 1] = '\0';
  73
  74     return 0;
  75 }
  76 */
  77
  78 static struct record_t* extract_info(const char* pathname, char *filename)
  79 {
  80     char *c, *mi, *dt, *end;
  81
  82     c = filename;
  83     end = filename;
  84
  85     while(*c != '\0') {
  86         end = c;
  87         c++;
  88     }
  89
  90     end++;
  91
  92     c = filename;
  93     mi = end;
  94
  95     while(c < end - 3) {
  96         if(c[0] == ' ' && (c[1] == '-' || c[1] == '_') && c[2] == ' ') {
  97             mi = c;
  98             break;
  99         }
 100
 101         c++;
 102     }
 103
 104     dt = strrchr(filename, '.');
 105
 106     struct record_t *lr = NULL;
 107
 108     char* artist = filename;
 109
 110     if(mi == end) {
 111                 lr = record_init(pathname, artist, "", NULL);
 112     } else {
 113                 *mi = '\0';
 114
 115                 if(dt)
 116                         *dt = '\0';
 117
 118                 char* title = mi + 3;
 119
 120                 lr = record_init(pathname, artist, title, NULL);
 121     }
 122
 123     return lr;
 124 }
 125
 126 void library_init(struct library_t *li)
 127 {
 128         li->records = g_ptr_array_new();
 129 }
 130
 131 void clear_record(gpointer data, gpointer user_data)
 132 {
 133         record_destroy(data);
 134 }
 135
 136 void library_clear(struct library_t *li)
 137 {
 138         g_ptr_array_foreach(li->records, clear_record, NULL);
 139
 140         g_ptr_array_free(li->records, FALSE);
 141 }
 142
 143
 144 void library_add(struct library_t *li, struct record_t *lr)
 145 {
 146         g_ptr_array_add(li->records, lr);
 147 }
 148
 149 int library_import(struct library_t *li, char *path)
 150 {
 151     DIR *dir;
 152     struct dirent *de;
 153     struct record_t* record = NULL;
 154     struct stat st;
 155
 156     fprintf(stderr, "Scanning directory '%s'...\n", path);
 157
 158     dir = opendir(path);
 159     if(!dir) {
 160         fprintf(stderr, "Failed to scan; aborting.\n");
 161         return -1;
 162     }
 163
 164     while((de = readdir(dir)) != NULL) {
 165
 166         if(de->d_name[0] == '.') // hidden or '.' or '..'
 167             continue;
 168
 169         char* pathname = g_newa(char, strlen(path) + 1 + strlen(de->d_name) + 1);
 170         sprintf(pathname, "%s%c%s", path, G_DIR_SEPARATOR, de->d_name);
 171
 172         if(stat(pathname, &st) == -1) {
 173             perror("stat");
 174             continue;
 175         }
 176
 177         // If the entry is a directory, recursively import the contents
 178         // of the directory. Otherwise, assume a file.
 179
 180         if(S_ISDIR(st.st_mode)) {
 181             library_import(li, pathname);
 182
 183         } else {
 184             record = extract_info(pathname, de->d_name);
 185             library_add(li, record);
 186         }
 187     }
 188
 189     closedir(dir);
 190
 191     return 0;
 192 }
 193
 194 unsigned int library_get_count(struct library_t* li)
 195 {
 196         return li->records->len;
 197 }
 198
 199 struct record_t* library_get_record(struct library_t* li, const guint index)
 200 {
 201         return g_ptr_array_index(li->records, index);
 202 }
 203
 204 void library_get_listing(struct library_t *li, struct listing_t *ls)
 205 {
 206     int n;
 207
 208     for(n = 0; n < library_get_count(li); n++)
 209         listing_add(ls, library_get_record(li, n));
 210 }
 211
 212
 213 void listing_init(struct listing_t *ls)
 214 {
 215     ls->records = g_ptr_array_new();
 216 }
 217
 218
 219 void listing_clear(struct listing_t *ls)
 220 {
 221         g_ptr_array_free(ls->records, FALSE);
 222 }
 223
 224
 225 void listing_blank(struct listing_t *ls)
 226 {
 227         if(ls->records->len != 0)
 228                 g_ptr_array_remove_range(ls->records, 0, listing_get_count(ls) - 1);
 229 }
 230
 231 size_t listing_get_count(const struct listing_t* ls)
 232 {
 233         return ls->records->len;
 234 }
 235
 236 guint listing_get_field_size(const struct listing_t* ls, const unsigned int index)
 237 {
 238         return 200;
 239 }
 240
 241 void listing_add(struct listing_t *ls, struct record_t *lr)
 242 {
 243         g_ptr_array_add(ls->records, lr);
 244 }
 245
 246 struct record_t* listing_get_record(const struct listing_t* ls, guint index)
 247 {
 248         return g_ptr_array_index(ls->records, index);
 249 }
 250
 251 gint compare_records(gconstpointer a, gconstpointer b)
 252 {
 253         return strcmp(record_get_name(a), record_get_name(b));
 254 }
 255
 256 void listing_sort(struct listing_t *ls)
 257 {
 258         g_ptr_array_sort(ls->records, compare_records);
 259 }
 260
 261 int listing_match(struct listing_t *src, struct listing_t *dest, char *match)
 262 {
 263     int n;
 264     struct record_t *re;
 265
 266     fprintf(stderr, "Matching '%s'\n", match);
 267
 268     for(n = 0; n < listing_get_count(src); n++) {
 269         re = listing_get_record(src, n);
 270
 271         if(strmatch(match, record_get_name(re)))
 272             listing_add(dest, re);
 273     }
 274
 275     return 0;
 276 }
 277
 278 void listing_debug(struct listing_t *ls)
 279 {
 280     int n;
 281
 282         struct record_t* record = NULL;
 283
 284         for(n = 0; (record = listing_get_record(ls, n)); n++)
 285         {
 286                 fprintf(stderr, "%d: %s\n", n, record_get_name(record));
 287         }
 288 }
 289