id3.c

   1 /*
   2  * Copyright 2005 Timo Hirvonen
   3  */
   4
   5 #include "id3.h"
   6 #include "comment.h"
   7 #include "xmalloc.h"
   8 #include "utf8_encode.h"
   9 #include "uchar.h"
  10 #include "options.h"
  11 #include "debug.h"
  12
  13 #include <unistd.h>
  14 #include <inttypes.h>
  15 #include <errno.h>
  16 #include <stdio.h>
  17
  18 /*
  19  * position:
  20  *
  21  *    0 "ID3"
  22  *  -10 "3DI"
  23  * -128 "TAG"
  24  * -138 "3DI"
  25  *
  26  * if v2 is at beginning _and_ at end then there must be a seek tag at beginning
  27  */
  28
  29 struct ID3 {
  30         char v1[128];
  31         char *v2[NUM_ID3_KEYS];
  32
  33         unsigned int has_v1 : 1;
  34         unsigned int has_v2 : 1;
  35 };
  36
  37 struct v2_header {
  38         unsigned char ver_major;
  39         unsigned char ver_minor;
  40         unsigned char flags;
  41         uint32_t size;
  42 };
  43
  44 struct v2_extended_header {
  45         uint32_t size;
  46 };
  47
  48 struct v2_frame_header {
  49         char id[4];
  50         uint32_t size;
  51         uint16_t flags;
  52 };
  53
  54 #define V2_HEADER_UNSYNC        (1 << 7)
  55 #define V2_HEADER_EXTENDED      (1 << 6)
  56 #define V2_HEADER_EXPERIMENTAL  (1 << 5)
  57 #define V2_HEADER_FOOTER        (1 << 4)
  58
  59 #define V2_FRAME_COMPRESSED     (1 << 3) /* great idea!!1 */
  60 #define V2_FRAME_ENCRYPTHED     (1 << 2) /* wow, this is very neat! */
  61 #define V2_FRAME_UNSYNC         (1 << 1)
  62 #define V2_FRAME_LEN_INDICATOR  (1 << 0)
  63
  64 #define NR_GENRES 148
  65 /* genres {{{ */
  66 static const char *genres[NR_GENRES] = {
  67         "Blues",
  68         "Classic Rock",
  69         "Country",
  70         "Dance",
  71         "Disco",
  72         "Funk",
  73         "Grunge",
  74         "Hip-Hop",
  75         "Jazz",
  76         "Metal",
  77         "New Age",
  78         "Oldies",
  79         "Other",
  80         "Pop",
  81         "R&B",
  82         "Rap",
  83         "Reggae",
  84         "Rock",
  85         "Techno",
  86         "Industrial",
  87         "Alternative",
  88         "Ska",
  89         "Death Metal",
  90         "Pranks",
  91         "Soundtrack",
  92         "Euro-Techno",
  93         "Ambient",
  94         "Trip-Hop",
  95         "Vocal",
  96         "Jazz+Funk",
  97         "Fusion",
  98         "Trance",
  99         "Classical",
 100         "Instrumental",
 101         "Acid",
 102         "House",
 103         "Game",
 104         "Sound Clip",
 105         "Gospel",
 106         "Noise",
 107         "Alt",
 108         "Bass",
 109         "Soul",
 110         "Punk",
 111         "Space",
 112         "Meditative",
 113         "Instrumental Pop",
 114         "Instrumental Rock",
 115         "Ethnic",
 116         "Gothic",
 117         "Darkwave",
 118         "Techno-Industrial",
 119         "Electronic",
 120         "Pop-Folk",
 121         "Eurodance",
 122         "Dream",
 123         "Southern Rock",
 124         "Comedy",
 125         "Cult",
 126         "Gangsta Rap",
 127         "Top 40",
 128         "Christian Rap",
 129         "Pop/Funk",
 130         "Jungle",
 131         "Native American",
 132         "Cabaret",
 133         "New Wave",
 134         "Psychedelic",
 135         "Rave",
 136         "Showtunes",
 137         "Trailer",
 138         "Lo-Fi",
 139         "Tribal",
 140         "Acid Punk",
 141         "Acid Jazz",
 142         "Polka",
 143         "Retro",
 144         "Musical",
 145         "Rock & Roll",
 146         "Hard Rock",
 147         "Folk",
 148         "Folk/Rock",
 149         "National Folk",
 150         "Swing",
 151         "Fast-Fusion",
 152         "Bebob",
 153         "Latin",
 154         "Revival",
 155         "Celtic",
 156         "Bluegrass",
 157         "Avantgarde",
 158         "Gothic Rock",
 159         "Progressive Rock",
 160         "Psychedelic Rock",
 161         "Symphonic Rock",
 162         "Slow Rock",
 163         "Big Band",
 164         "Chorus",
 165         "Easy Listening",
 166         "Acoustic",
 167         "Humour",
 168         "Speech",
 169         "Chanson",
 170         "Opera",
 171         "Chamber Music",
 172         "Sonata",
 173         "Symphony",
 174         "Booty Bass",
 175         "Primus",
 176         "Porn Groove",
 177         "Satire",
 178         "Slow Jam",
 179         "Club",
 180         "Tango",
 181         "Samba",
 182         "Folklore",
 183         "Ballad",
 184         "Power Ballad",
 185         "Rhythmic Soul",
 186         "Freestyle",
 187         "Duet",
 188         "Punk Rock",
 189         "Drum Solo",
 190         "A Cappella",
 191         "Euro-House",
 192         "Dance Hall",
 193         "Goa",
 194         "Drum & Bass",
 195         "Club-House",
 196         "Hardcore",
 197         "Terror",
 198         "Indie",
 199         "BritPop",
 200         "Negerpunk",
 201         "Polsk Punk",
 202         "Beat",
 203         "Christian Gangsta Rap",
 204         "Heavy Metal",
 205         "Black Metal",
 206         "Crossover",
 207         "Contemporary Christian",
 208         "Christian Rock",
 209         "Merengue",
 210         "Salsa",
 211         "Thrash Metal",
 212         "Anime",
 213         "JPop",
 214         "Synthpop"
 215 };
 216 /* }}} */
 217
 218 #if 1
 219 #define id3_debug(...) d_print(__VA_ARGS__)
 220 #else
 221 #define id3_debug(...) do { } while (0)
 222 #endif
 223
 224 static int utf16_is_special(const uchar uch)
 225 {
 226         if (UTF16_IS_HSURROGATE(uch) || UTF16_IS_LSURROGATE(uch) || UTF16_IS_BOM(uch))
 227                 return -1;
 228         return 0;
 229 }
 230
 231 static char *utf16_to_utf8(const unsigned char *buf, int buf_size)
 232 {
 233         char *out;
 234         int i, idx;
 235
 236         out = xnew(char, (buf_size / 2) * 4 + 1);
 237         i = idx = 0;
 238         while (buf_size - i >= 2) {
 239                 uchar u;
 240
 241                 u = buf[i] + (buf[i + 1] << 8);
 242                 if (u_is_unicode(u)) {
 243                         if (utf16_is_special(u) == 0)
 244                                 u_set_char(out, &idx, u);
 245                 } else {
 246                         free(out);
 247                         return NULL;
 248                 }
 249                 if (u == 0)
 250                         return out;
 251                 i += 2;
 252         }
 253         u_set_char(out, &idx, 0);
 254         return out;
 255 }
 256
 257 static char *utf16be_to_utf8(const unsigned char *buf, int buf_size)
 258 {
 259         char *out;
 260         int i, idx;
 261
 262         out = xnew(char, (buf_size / 2) * 4 + 1);
 263         i = 0;
 264         idx = 0;
 265         while (buf_size - i >= 2) {
 266                 uchar u;
 267
 268                 u = buf[i + 1] + (buf[i] << 8);
 269                 if (u_is_unicode(u)) {
 270                        if (utf16_is_special(u) == 0)
 271                                 u_set_char(out, &idx, u);
 272                 } else {
 273                         free(out);
 274                         return NULL;
 275                 }
 276                 if (u == 0)
 277                         return out;
 278                 i += 2;
 279         }
 280         u_set_char(out, &idx, 0);
 281         return out;
 282 }
 283
 284 static int is_v1(const char *buf)
 285 {
 286         return buf[0] == 'T' && buf[1] == 'A' && buf[2] == 'G';
 287 }
 288
 289 static int u32_unsync(const unsigned char *buf, uint32_t *up)
 290 {
 291         uint32_t b, u = 0;
 292         int i;
 293
 294         for (i = 0; i < 4; i++) {
 295                 b = buf[i];
 296                 if (b >= 0x80)
 297                         return 0;
 298                 u <<= 7;
 299                 u |= b;
 300         }
 301         *up = u;
 302         return 1;
 303 }
 304
 305 static void get_u32(const unsigned char *buf, uint32_t *up)
 306 {
 307         uint32_t b, u = 0;
 308         int i;
 309
 310         for (i = 0; i < 4; i++) {
 311                 b = buf[i];
 312                 u <<= 8;
 313                 u |= b;
 314         }
 315         *up = u;
 316 }
 317
 318 static void get_u24(const unsigned char *buf, uint32_t *up)
 319 {
 320         uint32_t b, u = 0;
 321         int i;
 322
 323         for (i = 0; i < 3; i++) {
 324                 b = buf[i];
 325                 u <<= 8;
 326                 u |= b;
 327         }
 328         *up = u;
 329 }
 330
 331 static int v2_header_footer_parse(struct v2_header *header, const char *buf)
 332 {
 333         const unsigned char *b = (const unsigned char *)buf;
 334
 335         header->ver_major = b[3];
 336         header->ver_minor = b[4];
 337         header->flags = b[5];
 338         if (header->ver_major == 0xff || header->ver_minor == 0xff)
 339                 return 0;
 340         return u32_unsync(b + 6, &header->size);
 341 }
 342
 343 static int v2_header_parse(struct v2_header *header, const char *buf)
 344 {
 345         if (buf[0] != 'I' || buf[1] != 'D' || buf[2] != '3')
 346                 return 0;
 347         return v2_header_footer_parse(header, buf);
 348 }
 349
 350 static int v2_footer_parse(struct v2_header *header, const char *buf)
 351 {
 352         if (buf[0] != '3' || buf[1] != 'D' || buf[2] != 'I')
 353                 return 0;
 354         return v2_header_footer_parse(header, buf);
 355 }
 356
 357 static int v2_extended_header_parse(struct v2_extended_header *header, const char *buf)
 358 {
 359         return u32_unsync((const unsigned char *)buf, &header->size);
 360 }
 361
 362 static int is_frame_id_char(char ch)
 363 {
 364         return (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9');
 365 }
 366
 367 /* XXXYYY
 368  *
 369  * X = [A-Z0-9]
 370  * Y = byte
 371  *
 372  * XXX is frame
 373  * YYY is frame size excluding this 6 byte header
 374  */
 375 static int v2_2_0_frame_header_parse(struct v2_frame_header *header, const char *buf)
 376 {
 377         int i;
 378
 379         for (i = 0; i < 3; i++) {
 380                 if (!is_frame_id_char(buf[i]))
 381                         return 0;
 382                 header->id[i] = buf[i];
 383         }
 384         header->id[3] = 0;
 385         get_u24((const unsigned char *)(buf + 3), &header->size);
 386         header->flags = 0;
 387         if (header->size == 0)
 388                 return 0;
 389         id3_debug("%c%c%c %d\n", header->id[0], header->id[1], header->id[2], header->size);
 390         return 1;
 391 }
 392
 393 /* XXXXYYYYZZ
 394  *
 395  * X = [A-Z0-9]
 396  * Y = byte
 397  * Z = byte
 398  *
 399  * XXXX is frame
 400  * YYYY is frame size excluding this 10 byte header
 401  * ZZ   is flags
 402  */
 403 static int v2_3_0_frame_header_parse(struct v2_frame_header *header, const char *buf)
 404 {
 405         int i;
 406
 407         for (i = 0; i < 4; i++) {
 408                 if (!is_frame_id_char(buf[i]))
 409                         return 0;
 410                 header->id[i] = buf[i];
 411         }
 412         get_u32((const unsigned char *)(buf + 4), &header->size);
 413         header->flags = (buf[8] << 8) | buf[9];
 414         if (header->size == 0)
 415                 return 0;
 416         id3_debug("%c%c%c%c %d\n", header->id[0], header->id[1], header->id[2],
 417                         header->id[3], header->size);
 418         return 1;
 419 }
 420
 421 /* same as 2.3 but header size is sync safe */
 422 static int v2_4_0_frame_header_parse(struct v2_frame_header *header, const char *buf)
 423 {
 424         int i;
 425
 426         for (i = 0; i < 4; i++) {
 427                 if (!is_frame_id_char(buf[i]))
 428                         return 0;
 429                 header->id[i] = buf[i];
 430         }
 431         if (!u32_unsync((const unsigned char *)(buf + 4), &header->size))
 432                 return 0;
 433         header->flags = (buf[8] << 8) | buf[9];
 434         if (header->size == 0)
 435                 return 0;
 436         id3_debug("%c%c%c%c %d\n", header->id[0], header->id[1], header->id[2],
 437                         header->id[3], header->size);
 438         return 1;
 439 }
 440
 441 static int read_all(int fd, char *buf, size_t size)
 442 {
 443         size_t pos = 0;
 444
 445         while (pos < size) {
 446                 int rc = read(fd, buf + pos, size - pos);
 447
 448                 if (rc == -1) {
 449                         if (errno == EINTR || errno == EAGAIN)
 450                                 continue;
 451                         return -1;
 452                 }
 453                 pos += rc;
 454         }
 455         return 0;
 456 }
 457
 458 static char *parse_genre(const char *str)
 459 {
 460         int parenthesis = 0;
 461         long int idx;
 462         char *end;
 463
 464         if (strncasecmp(str, "(RX", 3) == 0)
 465                 return xstrdup("Remix");
 466
 467         if (strncasecmp(str, "(CR", 3) == 0)
 468                 return xstrdup("Cover");
 469
 470         if (*str == '(') {
 471                 parenthesis = 1;
 472                 str++;
 473         }
 474
 475         idx = strtol(str, &end, 10);
 476         if (str != end) {
 477                 /* Number parsed but there may be some crap after the number.
 478                  * I don't care, ID3v2 by definition contains crap.
 479                  */
 480                 if (idx >= 0 && idx < NR_GENRES)
 481                         return xstrdup(genres[idx]);
 482         }
 483
 484         if (parenthesis) {
 485                 const char *ptr = strchr(str, ')');
 486
 487                 if (ptr && ptr[1]) {
 488                         /* genre name after random crap in parenthesis,
 489                          * return the genre name */
 490                         return xstrdup(ptr + 1);
 491                 }
 492                 str--;
 493         }
 494
 495         /* random crap, just return it and wait for a bug report */
 496         return xstrdup(str);
 497 }
 498
 499 /* http://www.id3.org/id3v2.4.0-structure.txt */
 500 static struct {
 501         const char name[8];
 502         enum id3_key key;
 503 } frame_tab[] = {
 504         /* 2.4.0 */
 505         { "TDRC", ID3_DATE },
 506
 507         /* >= 2.3.0 */
 508         { "TPE1", ID3_ARTIST },
 509         { "TALB", ID3_ALBUM },
 510         { "TIT2", ID3_TITLE },
 511         { "TYER", ID3_DATE },
 512         { "TCON", ID3_GENRE },
 513         { "TPOS", ID3_DISC },
 514         { "TRCK", ID3_TRACK },
 515         { "TPE2", ID3_ALBUMARTIST },
 516
 517         /* obsolete frames (2.2.0) */
 518         { "TP1",  ID3_ARTIST },
 519         { "TAL",  ID3_ALBUM },
 520         { "TT2",  ID3_TITLE },
 521         { "TYE",  ID3_DATE },
 522         { "TCO",  ID3_GENRE },
 523         { "TPA",  ID3_DISC },
 524         { "TRK",  ID3_TRACK },
 525
 526         { "", -1 }
 527 };
 528
 529 static void v2_add_frame(ID3 *id3, struct v2_frame_header *fh, const char *buf)
 530 {
 531         int i, encoding = *buf++, len = fh->size - 1;
 532
 533         if (encoding > 3)
 534                 return;
 535
 536         for (i = 0; frame_tab[i].key != -1; i++) {
 537                 enum id3_key key = frame_tab[i].key;
 538                 char *in, *out;
 539                 int rc;
 540
 541                 if (strncmp(fh->id, frame_tab[i].name, 4))
 542                         continue;
 543
 544                 switch (encoding) {
 545                 case 0x00: /* ISO-8859-1 */
 546                         in = xstrndup(buf, len);
 547                         rc = utf8_encode(in, id3_default_charset, &out);
 548                         free(in);
 549                         if (rc)
 550                                 return;
 551                         break;
 552                 case 0x03: /* UTF-8 */
 553                         in = xstrndup(buf, len);
 554                         if (u_is_valid(in)) {
 555                                 out = in;
 556                         } else {
 557                                 rc = utf8_encode(in, id3_default_charset, &out);
 558                                 free(in);
 559                                 if (rc)
 560                                         return;
 561                         }
 562                         break;
 563                 case 0x01: /* UTF-16 */
 564                         out = utf16_to_utf8((const unsigned char *)buf, len);
 565                         if (out == NULL)
 566                                 return;
 567                         break;
 568                 case 0x02: /* UTF-16BE */
 569                         out = utf16be_to_utf8((const unsigned char *)buf, len);
 570                         if (out == NULL)
 571                                 return;
 572                         break;
 573                 }
 574                 if (key == ID3_TRACK || key == ID3_DISC)
 575                         fix_track_or_disc(out);
 576                 if (key == ID3_GENRE) {
 577                         char *tmp;
 578
 579                         id3_debug("genre before: '%s'\n", out);
 580                         tmp = parse_genre(out);
 581                         free(out);
 582                         out = tmp;
 583                 }
 584                 free(id3->v2[key]);
 585                 id3->v2[key] = out;
 586                 id3->has_v2 = 1;
 587                 id3_debug("%s '%s'\n", frame_tab[i].name, out);
 588                 break;
 589         }
 590 }
 591
 592 static void unsync(unsigned char *buf, int *lenp)
 593 {
 594         int len = *lenp;
 595         int s, d;
 596
 597         s = d = 0;
 598         while (s < len - 1) {
 599                 if (buf[s] == 0xff && buf[s + 1] == 0x00) {
 600                         /* 0xff 0x00 -> 0xff */
 601                         buf[d++] = 0xff;
 602                         s += 2;
 603
 604                         if (s < len - 2 && buf[s] == 0x00) {
 605                                 /* 0xff 0x00 0x00 -> 0xff 0x00 */
 606                                 buf[d++] = 0x00;
 607                                 s++;
 608                         }
 609                         continue;
 610                 }
 611                 buf[d++] = buf[s++];
 612         }
 613         if (s < len)
 614                 buf[d++] = buf[s++];
 615
 616         d_print("unsyncronization removed %d bytes\n", s - d);
 617         *lenp = d;
 618 }
 619
 620 static int v2_read(ID3 *id3, int fd, const struct v2_header *header)
 621 {
 622         char *buf;
 623         int rc, buf_size;
 624         int frame_start, i;
 625         int frame_header_size;
 626
 627         buf_size = header->size;
 628         buf = xnew(char, buf_size);
 629         rc = read_all(fd, buf, buf_size);
 630         if (rc) {
 631                 free(buf);
 632                 return rc;
 633         }
 634
 635         frame_start = 0;
 636         if (header->flags & V2_HEADER_EXTENDED) {
 637                 struct v2_extended_header ext;
 638
 639                 v2_extended_header_parse(&ext, buf);
 640                 if (ext.size > buf_size) {
 641                         id3_debug("extended header corrupted\n");
 642                         free(buf);
 643                         return -2;
 644                 }
 645                 frame_start = ext.size;
 646                 /* should check if update flag is set */
 647         }
 648
 649         if (header->flags & V2_HEADER_UNSYNC) {
 650                 int len = buf_size - frame_start;
 651
 652                 unsync((unsigned char *)(buf + frame_start), &len);
 653                 buf_size = len + frame_start;
 654         }
 655
 656         frame_header_size = 10;
 657         if (header->ver_major == 2)
 658                 frame_header_size = 6;
 659
 660         i = frame_start;
 661         while (i < buf_size - frame_header_size) {
 662                 struct v2_frame_header fh;
 663                 int len;
 664
 665                 if (header->ver_major == 2) {
 666                         if (!v2_2_0_frame_header_parse(&fh, buf + i))
 667                                 break;
 668                 } else if (header->ver_major == 3) {
 669                         if (!v2_3_0_frame_header_parse(&fh, buf + i))
 670                                 break;
 671                 } else {
 672                         /* assume v2.4 */
 673                         if (!v2_4_0_frame_header_parse(&fh, buf + i))
 674                                 break;
 675                 }
 676
 677                 i += frame_header_size;
 678                 if (fh.size > buf_size - i) {
 679                         id3_debug("frame too big\n");
 680                         break;
 681                 }
 682
 683                 len = fh.size;
 684                 if (fh.flags & V2_FRAME_UNSYNC) {
 685                         int tmp = len;
 686
 687                         unsync((unsigned char *)(buf + i), &tmp);
 688                         fh.size = tmp;
 689                 }
 690                 v2_add_frame(id3, &fh, buf + i);
 691                 i += len;
 692         }
 693
 694         free(buf);
 695         return 0;
 696 }
 697
 698 int id3_tag_size(const char *buf, int buf_size)
 699 {
 700         struct v2_header header;
 701
 702         if (buf_size < 10)
 703                 return 0;
 704         if (v2_header_parse(&header, buf)) {
 705                 if (header.flags & V2_HEADER_FOOTER) {
 706                         /* header + data + footer */
 707                         id3_debug("v2.%d.%d with footer\n", header.ver_major, header.ver_minor);
 708                         return 10 + header.size + 10;
 709                 }
 710                 /* header */
 711                 id3_debug("v2.%d.%d\n", header.ver_major, header.ver_minor);
 712                 return 10 + header.size;
 713         }
 714         if (buf_size >= 3 && is_v1(buf)) {
 715                 id3_debug("v1\n");
 716                 return 128;
 717         }
 718         return 0;
 719 }
 720
 721 ID3 *id3_new(void)
 722 {
 723         return xnew0(ID3, 1);
 724 }
 725
 726 void id3_free(ID3 *id3)
 727 {
 728         int i;
 729
 730         for (i = 0; i < NUM_ID3_KEYS; i++)
 731                 free(id3->v2[i]);
 732         free(id3);
 733 }
 734
 735 int id3_read_tags(ID3 *id3, int fd, unsigned int flags)
 736 {
 737         off_t off;
 738         int rc;
 739
 740         if (flags & ID3_V2) {
 741                 struct v2_header header;
 742                 char buf[138];
 743
 744                 rc = read_all(fd, buf, 10);
 745                 if (rc)
 746                         goto rc_error;
 747                 if (v2_header_parse(&header, buf)) {
 748                         rc = v2_read(id3, fd, &header);
 749                         if (rc)
 750                                 goto rc_error;
 751                         /* get v1 if needed */
 752                 } else {
 753                         /* get v2 from end and optionally v1 */
 754
 755                         off = lseek(fd, -138, SEEK_END);
 756                         if (off == -1)
 757                                 goto error;
 758                         rc = read_all(fd, buf, 138);
 759                         if (rc)
 760                                 goto rc_error;
 761
 762                         if (is_v1(buf + 10)) {
 763                                 if (flags & ID3_V1) {
 764                                         memcpy(id3->v1, buf + 10, 128);
 765                                         id3->has_v1 = 1;
 766                                 }
 767                                 if (v2_footer_parse(&header, buf)) {
 768                                         /* footer at end of file - 128 */
 769                                         off = lseek(fd, -(header.size + 138), SEEK_END);
 770                                         if (off == -1)
 771                                                 goto error;
 772                                         rc = v2_read(id3, fd, &header);
 773                                         if (rc)
 774                                                 goto rc_error;
 775                                 }
 776                         } else if (v2_footer_parse(&header, buf + 128)) {
 777                                 /* footer at end of file */
 778                                 off = lseek(fd, -(header.size + 10), SEEK_END);
 779                                 if (off == -1)
 780                                         goto error;
 781                                 rc = v2_read(id3, fd, &header);
 782                                 if (rc)
 783                                         goto rc_error;
 784                         }
 785                         return 0;
 786                 }
 787         }
 788         if (flags & ID3_V1) {
 789                 off = lseek(fd, -128, SEEK_END);
 790                 if (off == -1)
 791                         goto error;
 792                 rc = read_all(fd, id3->v1, 128);
 793                 if (rc)
 794                         goto rc_error;
 795                 id3->has_v1 = is_v1(id3->v1);
 796         }
 797         return 0;
 798 error:
 799         rc = -1;
 800 rc_error:
 801         return rc;
 802 }
 803
 804 static char *v1_get_str(const char *buf, int len)
 805 {
 806         char in[32];
 807         char *out;
 808         int i;
 809
 810         for (i = len - 1; i >= 0; i--) {
 811                 if (buf[i] != 0 && buf[i] != ' ')
 812                         break;
 813         }
 814         if (i == -1)
 815                 return NULL;
 816         memcpy(in, buf, i + 1);
 817         in[i + 1] = 0;
 818         if (u_is_valid(in))
 819                 return xstrdup(in);
 820         if (utf8_encode(in, id3_default_charset, &out))
 821                 return NULL;
 822         return out;
 823 }
 824
 825 char *id3_get_comment(ID3 *id3, enum id3_key key)
 826 {
 827         if (id3->has_v2) {
 828                 if (id3->v2[key])
 829                         return xstrdup(id3->v2[key]);
 830         }
 831         if (id3->has_v1) {
 832                 switch (key) {
 833                 case ID3_ARTIST:
 834                         return v1_get_str(id3->v1 + 33, 30);
 835                 case ID3_ALBUM:
 836                         return v1_get_str(id3->v1 + 63, 30);
 837                 case ID3_TITLE:
 838                         return v1_get_str(id3->v1 + 3, 30);
 839                 case ID3_DATE:
 840                         return v1_get_str(id3->v1 + 93, 4);
 841                 case ID3_GENRE:
 842                         {
 843                                 unsigned char idx = id3->v1[127];
 844
 845                                 if (idx >= NR_GENRES)
 846                                         return NULL;
 847                                 return xstrdup(genres[idx]);
 848                         }
 849                 case ID3_TRACK:
 850                         {
 851                                 char *t;
 852
 853                                 if (id3->v1[125] != 0)
 854                                         return NULL;
 855                                 t = xnew(char, 4);
 856                                 snprintf(t, 4, "%d", ((unsigned char *)id3->v1)[126]);
 857                                 return t;
 858                         }
 859                 case ID3_DISC:
 860                 case ID3_ALBUMARTIST:
 861                 case NUM_ID3_KEYS:
 862                         return NULL;
 863                 }
 864         }
 865         return NULL;
 866 }