src/share/grabbag/cuesheet.c

   1 /* grabbag - Convenience lib for various routines common to several tools
   2  * Copyright (C) 2002,2003,2004  Josh Coalson
   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  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #include "share/grabbag.h"
  20 #include "FLAC/assert.h"
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 unsigned grabbag__cuesheet_msf_to_frame(unsigned minutes, unsigned seconds, unsigned frames)
  26 {
  27         return ((minutes * 60) + seconds) * 75 + frames;
  28 }
  29
  30 void grabbag__cuesheet_frame_to_msf(unsigned frame, unsigned *minutes, unsigned *seconds, unsigned *frames)
  31 {
  32         *frames = frame % 75;
  33         frame /= 75;
  34         *seconds = frame % 60;
  35         frame /= 60;
  36         *minutes = frame;
  37 }
  38
  39 /* since we only care about values >= 0 or error, returns < 0 for any illegal string, else value */
  40 static int local__parse_int_(const char *s)
  41 {
  42         int ret = 0;
  43         char c;
  44
  45         if(*s == '\0')
  46                 return -1;
  47
  48         while('\0' != (c = *s++))
  49                 if(c >= '0' && c <= '9')
  50                         ret = ret * 10 + (c - '0');
  51                 else
  52                         return -1;
  53
  54         return ret;
  55 }
  56
  57 /* since we only care about values >= 0 or error, returns < 0 for any illegal string, else value */
  58 static FLAC__int64 local__parse_int64_(const char *s)
  59 {
  60         FLAC__int64 ret = 0;
  61         char c;
  62
  63         if(*s == '\0')
  64                 return -1;
  65
  66         while('\0' != (c = *s++))
  67                 if(c >= '0' && c <= '9')
  68                         ret = ret * 10 + (c - '0');
  69                 else
  70                         return -1;
  71
  72         return ret;
  73 }
  74
  75 /* accept '[0-9]+:[0-9][0-9]?:[0-9][0-9]?', but max second of 59 and max frame of 74, e.g. 0:0:0, 123:45:67
  76  * return sample number or <0 for error
  77  */
  78 static FLAC__int64 local__parse_msf_(const char *s)
  79 {
  80         FLAC__int64 ret, field;
  81         char c;
  82
  83         c = *s++;
  84         if(c >= '0' && c <= '9')
  85                 field = (c - '0');
  86         else
  87                 return -1;
  88         while(':' != (c = *s++)) {
  89                 if(c >= '0' && c <= '9')
  90                         field = field * 10 + (c - '0');
  91                 else
  92                         return -1;
  93         }
  94
  95         ret = field * 60 * 44100;
  96
  97         c = *s++;
  98         if(c >= '0' && c <= '9')
  99                 field = (c - '0');
 100         else
 101                 return -1;
 102         if(':' != (c = *s++)) {
 103                 if(c >= '0' && c <= '9') {
 104                         field = field * 10 + (c - '0');
 105                         c = *s++;
 106                         if(c != ':')
 107                                 return -1;
 108                 }
 109                 else
 110                         return -1;
 111         }
 112
 113         if(field >= 60)
 114                 return -1;
 115
 116         ret += field * 44100;
 117
 118         c = *s++;
 119         if(c >= '0' && c <= '9')
 120                 field = (c - '0');
 121         else
 122                 return -1;
 123         if('\0' != (c = *s++)) {
 124                 if(c >= '0' && c <= '9') {
 125                         field = field * 10 + (c - '0');
 126                         c = *s++;
 127                 }
 128                 else
 129                         return -1;
 130         }
 131
 132         if(c != '\0')
 133                 return -1;
 134
 135         if(field >= 75)
 136                 return -1;
 137
 138         ret += field * (44100 / 75);
 139
 140         return ret;
 141 }
 142
 143 static char *local__get_field_(char **s, FLAC__bool allow_quotes)
 144 {
 145         FLAC__bool has_quote = false;
 146         char *p;
 147
 148         FLAC__ASSERT(0 != s);
 149
 150         if(0 == *s)
 151                 return 0;
 152
 153         /* skip leading whitespace */
 154         while(**s && 0 != strchr(" \t\r\n", **s))
 155                 (*s)++;
 156
 157         if(**s == 0) {
 158                 *s = 0;
 159                 return 0;
 160         }
 161
 162         if(allow_quotes && (**s == '"')) {
 163                 has_quote = true;
 164                 (*s)++;
 165                 if(**s == 0) {
 166                         *s = 0;
 167                         return 0;
 168                 }
 169         }
 170
 171         p = *s;
 172
 173         if(has_quote) {
 174                 *s = strchr(*s, '\"');
 175                 /* if there is no matching end quote, it's an error */
 176                 if(0 == *s)
 177                         p = *s = 0;
 178                 else {
 179                         **s = '\0';
 180                         (*s)++;
 181                 }
 182         }
 183         else {
 184                 while(**s && 0 == strchr(" \t\r\n", **s))
 185                         (*s)++;
 186                 if(**s) {
 187                         **s = '\0';
 188                         (*s)++;
 189                 }
 190                 else
 191                         *s = 0;
 192         }
 193
 194         return p;
 195 }
 196
 197 static FLAC__bool local__cuesheet_parse_(FILE *file, const char **error_message, unsigned *last_line_read, FLAC__StreamMetadata *cuesheet, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
 198 {
 199 #if defined _MSC_VER || defined __MINGW32__
 200 #define FLAC__STRCASECMP stricmp
 201 #else
 202 #define FLAC__STRCASECMP strcasecmp
 203 #endif
 204         char buffer[4096], *line, *field;
 205         unsigned linelen, forced_leadout_track_num = 0;
 206         FLAC__uint64 forced_leadout_track_offset = 0;
 207         int in_track_num = -1, in_index_num = -1;
 208         FLAC__bool disc_has_catalog = false, track_has_flags = false, track_has_isrc = false, has_forced_leadout = false;
 209         FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
 210
 211         cs->lead_in = is_cdda? 2 * 44100 /* The default lead-in size for CD-DA */ : 0;
 212         cs->is_cd = is_cdda;
 213
 214         while(0 != fgets(buffer, sizeof(buffer), file)) {
 215                 (*last_line_read)++;
 216                 line = buffer;
 217
 218                 linelen = strlen(line);
 219                 if(line[linelen-1] != '\n') {
 220                         *error_message = "line too long";
 221                         return false;
 222                 }
 223
 224                 if(0 != (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 225                         if(0 == FLAC__STRCASECMP(field, "CATALOG")) {
 226                                 if(disc_has_catalog) {
 227                                         *error_message = "found multiple CATALOG commands";
 228                                         return false;
 229                                 }
 230                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/true))) {
 231                                         *error_message = "CATALOG is missing catalog number";
 232                                         return false;
 233                                 }
 234                                 if(strlen(field) >= sizeof(cs->media_catalog_number)) {
 235                                         *error_message = "CATALOG number is too long";
 236                                         return false;
 237                                 }
 238                                 if(is_cdda && (strlen(field) != 13 || strspn(field, "0123456789") != 13)) {
 239                                         *error_message = "CD-DA CATALOG number must be 13 decimal digits";
 240                                         return false;
 241                                 }
 242                                 strcpy(cs->media_catalog_number, field);
 243                                 disc_has_catalog = true;
 244                         }
 245                         else if(0 == FLAC__STRCASECMP(field, "FLAGS")) {
 246                                 if(track_has_flags) {
 247                                         *error_message = "found multiple FLAGS commands";
 248                                         return false;
 249                                 }
 250                                 if(in_track_num < 0 || in_index_num >= 0) {
 251                                         *error_message = "FLAGS command must come after TRACK but before INDEX";
 252                                         return false;
 253                                 }
 254                                 while(0 != (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 255                                         if(0 == FLAC__STRCASECMP(field, "PRE"))
 256                                                 cs->tracks[cs->num_tracks-1].pre_emphasis = 1;
 257                                 }
 258                                 track_has_flags = true;
 259                         }
 260                         else if(0 == FLAC__STRCASECMP(field, "INDEX")) {
 261                                 FLAC__int64 xx;
 262                                 FLAC__StreamMetadata_CueSheet_Track *track = &cs->tracks[cs->num_tracks-1];
 263                                 if(in_track_num < 0) {
 264                                         *error_message = "found INDEX before any TRACK";
 265                                         return false;
 266                                 }
 267                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 268                                         *error_message = "INDEX is missing index number";
 269                                         return false;
 270                                 }
 271                                 in_index_num = local__parse_int_(field);
 272                                 if(in_index_num < 0) {
 273                                         *error_message = "INDEX has invalid index number";
 274                                         return false;
 275                                 }
 276                                 FLAC__ASSERT(cs->num_tracks > 0);
 277                                 if(track->num_indices == 0) {
 278                                         /* it's the first index point of the track */
 279                                         if(in_index_num > 1) {
 280                                                 *error_message = "first INDEX number of a TRACK must be 0 or 1";
 281                                                 return false;
 282                                         }
 283                                 }
 284                                 else {
 285                                         if(in_index_num != track->indices[track->num_indices-1].number + 1) {
 286                                                 *error_message = "INDEX numbers must be sequential";
 287                                                 return false;
 288                                         }
 289                                 }
 290                                 if(is_cdda && in_index_num > 99) {
 291                                         *error_message = "CD-DA INDEX number must be between 0 and 99, inclusive";
 292                                         return false;
 293                                 }
 294                                 /*@@@ search for duplicate track number? */
 295                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 296                                         *error_message = "INDEX is missing an offset after the index number";
 297                                         return false;
 298                                 }
 299                                 xx = local__parse_msf_(field);
 300                                 if(xx < 0) {
 301                                         if(is_cdda) {
 302                                                 *error_message = "illegal INDEX offset (not of the form MM:SS:FF)";
 303                                                 return false;
 304                                         }
 305                                         xx = local__parse_int64_(field);
 306                                         if(xx < 0) {
 307                                                 *error_message = "illegal INDEX offset";
 308                                                 return false;
 309                                         }
 310                                 }
 311                                 if(is_cdda && cs->num_tracks == 1 && cs->tracks[0].num_indices == 0 && xx != 0) {
 312                                         *error_message = "first INDEX of first TRACK must have an offset of 00:00:00";
 313                                         return false;
 314                                 }
 315                                 if(is_cdda && track->num_indices > 0 && (FLAC__uint64)xx <= track->indices[track->num_indices-1].offset) {
 316                                         *error_message = "CD-DA INDEX offsets must increase in time";
 317                                         return false;
 318                                 }
 319                                 /* fill in track offset if it's the first index of the track */
 320                                 if(track->num_indices == 0)
 321                                         track->offset = (FLAC__uint64)xx;
 322                                 if(is_cdda && cs->num_tracks > 1) {
 323                                         const FLAC__StreamMetadata_CueSheet_Track *prev = &cs->tracks[cs->num_tracks-2];
 324                                         if((FLAC__uint64)xx <= prev->offset + prev->indices[prev->num_indices-1].offset) {
 325                                                 *error_message = "CD-DA INDEX offsets must increase in time";
 326                                                 return false;
 327                                         }
 328                                 }
 329                                 if(!FLAC__metadata_object_cuesheet_track_insert_blank_index(cuesheet, cs->num_tracks-1, track->num_indices)) {
 330                                         *error_message = "memory allocation error";
 331                                         return false;
 332                                 }
 333                                 track->indices[track->num_indices-1].offset = (FLAC__uint64)xx - track->offset;
 334                                 track->indices[track->num_indices-1].number = in_index_num;
 335                         }
 336                         else if(0 == FLAC__STRCASECMP(field, "ISRC")) {
 337                                 char *l, *r;
 338                                 if(track_has_isrc) {
 339                                         *error_message = "found multiple ISRC commands";
 340                                         return false;
 341                                 }
 342                                 if(in_track_num < 0 || in_index_num >= 0) {
 343                                         *error_message = "ISRC command must come after TRACK but before INDEX";
 344                                         return false;
 345                                 }
 346                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 347                                         *error_message = "ISRC is missing ISRC number";
 348                                         return false;
 349                                 }
 350                                 /* strip out dashes */
 351                                 for(l = r = field; *r; r++) {
 352                                         if(*r != '-')
 353                                                 *l++ = *r;
 354                                 }
 355                                 *l = '\0';
 356                                 if(strlen(field) != 12 || strspn(field, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") < 5 || strspn(field+5, "1234567890") != 7) {
 357                                         *error_message = "invalid ISRC number";
 358                                         return false;
 359                                 }
 360                                 strcpy(cs->tracks[cs->num_tracks-1].isrc, field);
 361                                 track_has_isrc = true;
 362                         }
 363                         else if(0 == FLAC__STRCASECMP(field, "TRACK")) {
 364                                 if(cs->num_tracks > 0) {
 365                                         const FLAC__StreamMetadata_CueSheet_Track *prev = &cs->tracks[cs->num_tracks-1];
 366                                         if(
 367                                                 prev->num_indices == 0 ||
 368                                                 (
 369                                                         is_cdda &&
 370                                                         (
 371                                                                 (prev->num_indices == 1 && prev->indices[0].number != 1) ||
 372                                                                 (prev->num_indices == 2 && prev->indices[0].number != 1 && prev->indices[1].number != 1)
 373                                                         )
 374                                                 )
 375                                         ) {
 376                                                 *error_message = is_cdda?
 377                                                         "previous TRACK must specify at least one INDEX 01" :
 378                                                         "previous TRACK must specify at least one INDEX";
 379                                                 return false;
 380                                         }
 381                                 }
 382                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 383                                         *error_message = "TRACK is missing track number";
 384                                         return false;
 385                                 }
 386                                 in_track_num = local__parse_int_(field);
 387                                 if(in_track_num < 0) {
 388                                         *error_message = "TRACK has invalid track number";
 389                                         return false;
 390                                 }
 391                                 if(in_track_num == 0) {
 392                                         *error_message = "TRACK number must be greater than 0";
 393                                         return false;
 394                                 }
 395                                 if(is_cdda && in_track_num > 99) {
 396                                         *error_message = "CD-DA TRACK number must be between 1 and 99, inclusive";
 397                                         return false;
 398                                 }
 399                                 if(is_cdda && cs->num_tracks > 0 && in_track_num != cs->tracks[cs->num_tracks-1].number + 1) {
 400                                         *error_message = "CD-DA TRACK numbers must be sequential";
 401                                         return false;
 402                                 }
 403                                 /*@@@ search for duplicate track number? */
 404                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 405                                         *error_message = "TRACK is missing a track type after the track number";
 406                                         return false;
 407                                 }
 408                                 if(!FLAC__metadata_object_cuesheet_insert_blank_track(cuesheet, cs->num_tracks)) {
 409                                         *error_message = "memory allocation error";
 410                                         return false;
 411                                 }
 412                                 cs->tracks[cs->num_tracks-1].number = in_track_num;
 413                                 cs->tracks[cs->num_tracks-1].type = (0 == FLAC__STRCASECMP(field, "AUDIO"))? 0 : 1; /*@@@ should we be more strict with the value here? */
 414                                 in_index_num = -1;
 415                                 track_has_flags = false;
 416                                 track_has_isrc = false;
 417                         }
 418                         else if(0 == FLAC__STRCASECMP(field, "REM")) {
 419                                 if(0 != (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 420                                         if(0 == strcmp(field, "FLAC__lead-in")) {
 421                                                 FLAC__int64 xx;
 422                                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 423                                                         *error_message = "FLAC__lead-in is missing offset";
 424                                                         return false;
 425                                                 }
 426                                                 xx = local__parse_int64_(field);
 427                                                 if(xx < 0) {
 428                                                         *error_message = "illegal FLAC__lead-in offset";
 429                                                         return false;
 430                                                 }
 431                                                 if(is_cdda && xx % 588 != 0) {
 432                                                         *error_message = "illegal CD-DA FLAC__lead-in offset, must be even multiple of 588 samples";
 433                                                         return false;
 434                                                 }
 435                                                 cs->lead_in = (FLAC__uint64)xx;
 436                                         }
 437                                         else if(0 == strcmp(field, "FLAC__lead-out")) {
 438                                                 int track_num;
 439                                                 FLAC__int64 offset;
 440                                                 if(has_forced_leadout) {
 441                                                         *error_message = "multiple FLAC__lead-out commands";
 442                                                         return false;
 443                                                 }
 444                                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 445                                                         *error_message = "FLAC__lead-out is missing track number";
 446                                                         return false;
 447                                                 }
 448                                                 track_num = local__parse_int_(field);
 449                                                 if(track_num < 0) {
 450                                                         *error_message = "illegal FLAC__lead-out track number";
 451                                                         return false;
 452                                                 }
 453                                                 forced_leadout_track_num = (unsigned)track_num;
 454                                                 /*@@@ search for duplicate track number? */
 455                                                 if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
 456                                                         *error_message = "FLAC__lead-out is missing offset";
 457                                                         return false;
 458                                                 }
 459                                                 offset = local__parse_int64_(field);
 460                                                 if(offset < 0) {
 461                                                         *error_message = "illegal FLAC__lead-out offset";
 462                                                         return false;
 463                                                 }
 464                                                 forced_leadout_track_offset = (FLAC__uint64)offset;
 465                                                 if(forced_leadout_track_offset != lead_out_offset) {
 466                                                         *error_message = "FLAC__lead-out offset does not match end-of-stream offset";
 467                                                         return false;
 468                                                 }
 469                                                 has_forced_leadout = true;
 470                                         }
 471                                 }
 472                         }
 473                 }
 474         }
 475
 476         if(cs->num_tracks == 0) {
 477                 *error_message = "there must be at least one TRACK command";
 478                 return false;
 479         }
 480         else {
 481                 const FLAC__StreamMetadata_CueSheet_Track *prev = &cs->tracks[cs->num_tracks-1];
 482                 if(
 483                         prev->num_indices == 0 ||
 484                         (
 485                                 is_cdda &&
 486                                 (
 487                                         (prev->num_indices == 1 && prev->indices[0].number != 1) ||
 488                                         (prev->num_indices == 2 && prev->indices[0].number != 1 && prev->indices[1].number != 1)
 489                                 )
 490                         )
 491                 ) {
 492                         *error_message = is_cdda?
 493                                 "previous TRACK must specify at least one INDEX 01" :
 494                                 "previous TRACK must specify at least one INDEX";
 495                         return false;
 496                 }
 497         }
 498
 499         if(!has_forced_leadout) {
 500                 forced_leadout_track_num = is_cdda? 170 : cs->num_tracks;
 501                 forced_leadout_track_offset = lead_out_offset;
 502         }
 503         if(!FLAC__metadata_object_cuesheet_insert_blank_track(cuesheet, cs->num_tracks)) {
 504                 *error_message = "memory allocation error";
 505                 return false;
 506         }
 507         cs->tracks[cs->num_tracks-1].number = forced_leadout_track_num;
 508         cs->tracks[cs->num_tracks-1].offset = forced_leadout_track_offset;
 509
 510         if(!feof(file)) {
 511                 *error_message = "read error";
 512                 return false;
 513         }
 514         return true;
 515 #undef FLAC__STRCASECMP
 516 }
 517
 518 FLAC__StreamMetadata *grabbag__cuesheet_parse(FILE *file, const char **error_message, unsigned *last_line_read, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
 519 {
 520         FLAC__StreamMetadata *cuesheet;
 521
 522         FLAC__ASSERT(0 != file);
 523         FLAC__ASSERT(0 != error_message);
 524         FLAC__ASSERT(0 != last_line_read);
 525
 526         *last_line_read = 0;
 527         cuesheet = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
 528
 529         if(0 == cuesheet) {
 530                 *error_message = "memory allocation error";
 531                 return 0;
 532         }
 533
 534         if(!local__cuesheet_parse_(file, error_message, last_line_read, cuesheet, is_cdda, lead_out_offset)) {
 535                 FLAC__metadata_object_delete(cuesheet);
 536                 return 0;
 537         }
 538
 539         return cuesheet;
 540 }
 541
 542 void grabbag__cuesheet_emit(FILE *file, const FLAC__StreamMetadata *cuesheet, const char *file_reference)
 543 {
 544         const FLAC__StreamMetadata_CueSheet *cs;
 545         unsigned track_num, index_num;
 546
 547         FLAC__ASSERT(0 != file);
 548         FLAC__ASSERT(0 != cuesheet);
 549         FLAC__ASSERT(cuesheet->type == FLAC__METADATA_TYPE_CUESHEET);
 550
 551         cs = &cuesheet->data.cue_sheet;
 552
 553         if(*(cs->media_catalog_number))
 554                 fprintf(file, "CATALOG %s\n", cs->media_catalog_number);
 555         fprintf(file, "FILE %s\n", file_reference);
 556
 557         for(track_num = 0; track_num < cs->num_tracks-1; track_num++) {
 558                 const FLAC__StreamMetadata_CueSheet_Track *track = cs->tracks + track_num;
 559
 560                 fprintf(file, "  TRACK %02u %s\n", (unsigned)track->number, track->type == 0? "AUDIO" : "DATA");
 561
 562                 if(track->pre_emphasis)
 563                         fprintf(file, "    FLAGS PRE\n");
 564                 if(*(track->isrc))
 565                         fprintf(file, "    ISRC %s\n", track->isrc);
 566
 567                 for(index_num = 0; index_num < track->num_indices; index_num++) {
 568                         const FLAC__StreamMetadata_CueSheet_Index *index = track->indices + index_num;
 569
 570                         fprintf(file, "    INDEX %02u ", (unsigned)index->number);
 571                         if(cs->is_cd) {
 572                                 const unsigned logical_frame = (unsigned)((track->offset + index->offset) / (44100 / 75));
 573                                 unsigned m, s, f;
 574                                 grabbag__cuesheet_frame_to_msf(logical_frame, &m, &s, &f);
 575                                 fprintf(file, "%02u:%02u:%02u\n", m, s, f);
 576                         }
 577                         else
 578 #ifdef _MSC_VER
 579                                 fprintf(file, "%I64u\n", track->offset + index->offset);
 580 #else
 581                                 fprintf(file, "%llu\n", track->offset + index->offset);
 582 #endif
 583                 }
 584         }
 585
 586 #ifdef _MSC_VER
 587         fprintf(file, "REM FLAC__lead-in %I64u\n", cs->lead_in);
 588         fprintf(file, "REM FLAC__lead-out %u %I64u\n", (unsigned)cs->tracks[track_num].number, cs->tracks[track_num].offset);
 589 #else
 590         fprintf(file, "REM FLAC__lead-in %llu\n", cs->lead_in);
 591         fprintf(file, "REM FLAC__lead-out %u %llu\n", (unsigned)cs->tracks[track_num].number, cs->tracks[track_num].offset);
 592 #endif
 593 }