FryingPan/DTLib/rCUESession.cpp

   1 /*
   2  * FryingPan - Amiga CD/DVD Recording Software (User Interface and supporting Libraries only)
   3  * Copyright (C) 2001-2011 Tomasz Wiszkowski Tomasz.Wiszkowski at gmail.com
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public License
   7  * as published by the Free Software Foundation; either version 2.1
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program 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
  13  * GNU Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "rCUESession.h"
  21 #include <Generic/LibrarySpool.h>
  22 #include <libclass/dos.h>
  23 #include <Optical/IOptItem.h>
  24 #include "Main.h"
  25
  26
  27 class file
  28 {
  29 public:
  30    enum filetype
  31    {
  32       Type_Unknown,
  33       Type_Intel,
  34       Type_Motorola,
  35       Type_Wave,
  36       Type_AIFF,
  37       Type_MP3
  38    };
  39
  40 protected:
  41    String            filename;
  42    uint32            length;
  43    filetype          type;
  44    BPTR              fileptr;
  45
  46 private:
  47    file()
  48    {
  49       fileptr = 0;
  50       type = Type_Unknown;
  51       length = 0;
  52       filename = "";
  53    };
  54
  55    file(const file&) {};
  56
  57 public:
  58
  59    static file *newFile(const String &cue_location, const String &filename, const String &type)
  60    {
  61       BPTR           fileptr;
  62       String         path;
  63       FileInfoBlock *fib;
  64       file          *f;
  65
  66       path = cue_location;
  67       path.AddPath(filename);
  68
  69       fileptr = DOS->Open(path.Data(), MODE_OLDFILE);
  70       if (fileptr == 0)
  71          return 0;
  72
  73       f = new file;
  74       f->filename = path;
  75       f->fileptr = fileptr;
  76
  77       fib = new FileInfoBlock;
  78       DOS->ExamineFH(fileptr, fib);
  79       f->length = fib->fib_Size;
  80       delete fib;
  81
  82       if (type == "BINARY")
  83          f->type = Type_Intel;
  84       else if (type == "MOTOROLA")
  85          f->type = Type_Motorola;
  86       else if (type == "AIFF")
  87          f->type = Type_AIFF;
  88       else if (type == "WAVE")
  89          f->type = Type_Wave;
  90       else if (type == "MP3")
  91          f->type = Type_MP3;
  92       else
  93          f->type = Type_Unknown;
  94
  95       return f;
  96    }
  97
  98    ~file()
  99    {
 100       if (fileptr != 0)
 101          DOS->Close(fileptr);
 102       fileptr = 0;
 103    }
 104
 105    const String& getFileName() const
 106    {
 107       return filename;
 108    }
 109
 110    uint32 getFileSize() const
 111    {
 112       return length;
 113    }
 114
 115    file::filetype getFileType() const
 116    {
 117       return type;
 118    }
 119
 120    BPTR getFile() const
 121    {
 122       return fileptr;
 123    }
 124
 125    void seek(uint32 offset) const
 126    {
 127       DOS->Seek(fileptr, offset, OFFSET_BEGINNING);
 128    }
 129
 130    uint32 read(void* mem, uint32 len) const
 131    {
 132       return DOS->Read(fileptr, mem, len);
 133    }
 134 };
 135
 136 class index
 137 {
 138    uint16            num;     // index number
 139    uint32            loc;     // boundary: start
 140    uint32            cnt;     // and count
 141
 142    file*             f;
 143    uint32            fileoffset;
 144    uint32            datalength;
 145    uint32            currpos;
 146
 147
 148    index()
 149    {
 150       num = 0;
 151       loc = 0;
 152       cnt = 0;
 153       currpos = 0;
 154    }
 155 public:
 156
 157    static index *newIndex(uint16 number, uint32 location)
 158    {
 159       index *i = new index();
 160
 161       i->num = number;
 162       i->loc = location;
 163       i->cnt = 0xffffffff;
 164
 165       return i;
 166    }
 167
 168    void setSecCnt(uint32 scnt)
 169    {
 170       cnt = scnt;
 171    }
 172
 173    uint32 getSecCnt() const
 174    {
 175       return cnt;
 176    }
 177
 178    uint32 getLocation() const
 179    {
 180       return loc;
 181    }
 182
 183    void setLocation(uint32 l)
 184    {
 185       loc = l;
 186    }
 187
 188     void debug(DbgHandler *__dbg)
 189    {
 190       if (__dbg == 0)
 191          return;
 192
 193       _D(Lvl_Info, "---");
 194       _D(Lvl_Info, "Number:          %ld", num);
 195       _D(Lvl_Info, "Location:        %ld", loc);
 196       _D(Lvl_Info, "Sector Count:    %ld", cnt);
 197    }
 198
 199    void setFile(file* fl)
 200    {
 201       f = fl;
 202    }
 203
 204    file *getFile() const
 205    {
 206       return f;
 207    }
 208
 209    void setFileOffset(uint32 fo)
 210    {
 211       fileoffset = fo;
 212    }
 213
 214    void setDataLength(uint32 dl)
 215    {
 216       datalength = dl;
 217    }
 218
 219    uint32 getFileOffset() const
 220    {
 221       return fileoffset;
 222    }
 223
 224    uint32 getDataLength() const
 225    {
 226       return datalength;
 227    }
 228
 229    uint32 getNumber() const
 230    {
 231       return num;
 232    }
 233
 234    void fillItem(IOptItem* item)
 235    {
 236       item->setStartAddress(loc);
 237       item->setItemNumber(num);
 238       item->setDataBlockCount(cnt);
 239    }
 240
 241    void setUp()
 242    {
 243       currpos = 0xffffffff;
 244    }
 245
 246    uint32 read(void* mem, uint32 len)
 247    {
 248       if (currpos == datalength)
 249          return 0;
 250       if (currpos == 0xffffffff)
 251       {
 252          f->seek(fileoffset);
 253          currpos = 0;
 254       }
 255
 256       len = len < (datalength - currpos) ? len : (datalength - currpos);
 257       f->read(mem, len);                  // i don't care if data is valid
 258       currpos += len;                     // if it's not, i won't interrupt the process
 259       return len;
 260    }
 261 };
 262
 263 class track
 264 {
 265    EDataType         type;          // type of data
 266    uint32            flags;         // additional flags (like "RAW")
 267    uint16            secsize;       // resulting from the two above fields
 268    uint16            pregap;        // in sectors
 269    uint16            postgap;       // in sectors
 270    String            isrc;          // ISRC number
 271    int16             number;        // track number
 272    VectorT<index*>   indices;       // indices
 273
 274    int16             curridx;
 275
 276    String            arranger;      // CDText
 277    String            composer;
 278    String            performer;
 279    String            message;
 280    String            title;
 281    String            songwriter;
 282
 283    track()
 284    {
 285       type = Data_Unknown;
 286       flags = 0;
 287       secsize = 0;
 288       pregap = 0;
 289       postgap= 0;
 290       number = 0;
 291       curridx = 0;
 292    };
 293
 294 public:
 295    static track* newTrack(int32 num, const String &mode)
 296    {
 297       track *nt = new track;
 298
 299       nt->number = num;
 300
 301       if (mode == "AUDIO")
 302          nt->type = Data_Audio, nt->flags = 0, nt->secsize = 2352;
 303       else if (mode == "MDOE1/2048")
 304          nt->type = Data_Mode1, nt->flags = 0, nt->secsize = 2048;
 305       else if (mode == "MODE2/2336")
 306          nt->type = Data_Mode2, nt->flags = 0, nt->secsize = 2336;
 307       else if (mode == "MODE1/2352")
 308          nt->type = Data_Mode1, nt->flags = DIF_Common_RawData, nt->secsize = 2352;
 309       else if (mode == "MODE2/2352")
 310          nt->type = Data_Mode2, nt->flags = DIF_Common_RawData, nt->secsize = 2352;
 311       else
 312       {
 313          delete nt;
 314          return 0;
 315       }
 316
 317       return nt;
 318    }
 319
 320    void debug(DbgHandler *__dbg)
 321    {
 322       if (__dbg == 0)
 323          return;
 324
 325       _D(Lvl_Info, "Number:          %ld", number);
 326       _D(Lvl_Info, "File type:       %ld", type);
 327       _D(Lvl_Info, "Flags:           %ld", flags);
 328       _D(Lvl_Info, "Sector Size:     %ld", secsize);
 329       _D(Lvl_Info, "PreGap:          %ld", pregap);
 330       _D(Lvl_Info, "PostGap:         %ld", postgap);
 331       _D(Lvl_Info, "ISRC:            %s", (int32)isrc.Data());
 332       _D(Lvl_Info, "Arranger:        %s", (int32)arranger.Data());
 333       _D(Lvl_Info, "Composer:        %s", (int32)composer.Data());
 334       _D(Lvl_Info, "Performer:       %s", (int32)performer.Data());
 335       _D(Lvl_Info, "Message:         %s", (int32)message.Data());
 336       _D(Lvl_Info, "Title:           %s", (int32)title.Data());
 337       _D(Lvl_Info, "Song Writer:     %s", (int32)songwriter.Data());
 338
 339       for (int32 i=0; i<indices.Count(); i++)
 340          indices[i]->debug(__dbg);
 341
 342       _D(Lvl_Info, "===");
 343    }
 344
 345    void setArranger(const String &s)
 346    {
 347       arranger = s;
 348    }
 349
 350    void setComposer(const String &s)
 351    {
 352       composer = s;
 353    }
 354
 355    void setPerformer(const String &s)
 356    {
 357       performer = s;
 358    }
 359
 360    void setMessage(const String &s)
 361    {
 362       message = s;
 363    }
 364
 365    void setTitle(const String &s)
 366    {
 367       title = s;
 368    }
 369
 370    void setSongWriter(const String &s)
 371    {
 372       songwriter = s;
 373    }
 374
 375    void setPreGap(int32 gap)
 376    {
 377       pregap = gap;
 378    }
 379
 380    void setPostGap(int32 gap)
 381    {
 382       postgap = gap;
 383    }
 384
 385    int32 getPreGap() const
 386    {
 387       return pregap;
 388    }
 389
 390    int32 getPostGap() const
 391    {
 392       return postgap;
 393    }
 394
 395    int32 getNumber() const
 396    {
 397       return number;
 398    }
 399
 400    void setISRC(const String &s)
 401    {
 402       isrc = s;
 403    }
 404
 405    void addIndex(index *i)
 406    {
 407       indices << i;
 408    }
 409
 410    index *getIndex(int32 i)
 411    {
 412       return indices[i];
 413    }
 414
 415    int32 getIndexCount()
 416    {
 417       return indices.Count();
 418    }
 419
 420    int32 getSectorSize() const
 421    {
 422       return secsize;
 423    }
 424
 425    void fillItem(IOptItem *item)
 426    {
 427       uint32 len = 0;
 428
 429       item->setCDTDirector(arranger);
 430       item->setCDTComposer(composer);
 431       item->setCDTArtist(performer);
 432       item->setCDTMessage(message);
 433       item->setCDTTitle(title);
 434       item->setCDTLyrics(songwriter);
 435       item->setFlags(flags);
 436       item->setSectorSize(secsize);
 437       item->setPreGapSize(pregap);
 438       item->setItemNumber(number);
 439       item->setDataType(type);
 440
 441       item->setStartAddress(indices[0]->getLocation() - pregap);
 442       for (int32 i=0; i<indices.Count(); i++)
 443       {
 444          IOptItem *indx = item->addChild();
 445
 446          indices[i]->fillItem(indx);
 447          len += indices[i]->getSecCnt();
 448       }
 449       item->setDataBlockCount(len);
 450
 451 // FIXME: no postgap
 452
 453       // uint16            postgap;       // in sectors
 454       // String            isrc;          // ISRC number
 455    }
 456
 457    void setUp()
 458    {
 459       for (int i=0; i<indices.Count(); i++)
 460          indices[i]->setUp();
 461
 462       curridx = 0;
 463    }
 464
 465    uint32 read(void* &mem, uint32 len)
 466    {
 467       uint32 ret = 0;
 468
 469       len *= secsize;
 470
 471       while (curridx < indices.Count())
 472       {
 473          ret += indices[curridx]->read(mem, len - ret);
 474
 475          mem = &((char*)mem)[ret];
 476
 477          if (ret == len)
 478             break;
 479
 480          curridx++;
 481       }
 482
 483       return ret / secsize;
 484    }
 485 };
 486
 487
 488
 489 // TODO:
 490 // - use 'cdtextfile' parameter some day
 491 // - apply params such as 'isrc', 'upc_ean', 'disc_id'
 492 // - make class track return the data to the reader!!!!
 493
 494
 495
 496                      rCUESession::rCUESession(const char* sFileName, EDtError &rc)
 497 {
 498    _createDebug(true, "rCUESession");
 499    name = sFileName;
 500    analyse(sFileName, rc);
 501 }
 502
 503                      rCUESession::~rCUESession()
 504 {
 505    tracks.ForEach(&freeTrack);
 506    for (int i=0; i<files.Count(); i++)
 507       delete files[i];
 508    files.Empty();
 509
 510
 511    _destroyDebug();
 512 }
 513
 514 bool                 rCUESession::freeTrack(track* const& t)
 515 {
 516    delete t;
 517    return true;
 518 }
 519
 520 IFileReader*         rCUESession::openRead(const char* sFile, EDtError &rc)
 521 {
 522    IFileReader *out = 0;
 523
 524    checkFile(sFile, rc);
 525    if (rc == DT_OK)
 526    {
 527       out = new rCUESession(sFile, rc);
 528       if (rc != DT_OK)
 529       {
 530          out->dispose();
 531          out = 0;
 532       }
 533    }
 534    return out;
 535 }
 536
 537 const char*          rCUESession::getName()
 538 {
 539    return static_getName();
 540 }
 541
 542 bool                 rCUESession::readData(const IOptItem* item, void* mem, int len)
 543 {
 544    if (item->getItemType() != Item_Track)
 545    {
 546       int32 ret;
 547
 548       if (currtrk == tracks.Count())
 549          return false;
 550
 551       ret = tracks[currtrk]->read(mem, len);
 552       if (ret == len)
 553          return true;
 554
 555       currtrk++;
 556       ret += readData(item, mem, len-ret);
 557
 558       return true;
 559    }
 560    else
 561    {
 562       ASSERTS(false, "Functionality not yet implemented, sorry.");
 563       return false;
 564    }
 565 }
 566
 567 bool                 rCUESession::setUp()
 568 {
 569    _d(Lvl_Info, "%s: seeking all items to the start position...", (int)__PRETTY_FUNCTION__);
 570
 571    for (int i=0; i<tracks.Count(); i++)
 572       tracks[i]->setUp();
 573
 574    for (int i=0; i<files.Count(); i++)
 575       DOS->Seek(files[i]->getFile(), 0, OFFSET_BEGINNING);
 576
 577    currtrk = 0;
 578
 579    return true;
 580 }
 581
 582 bool                 rCUESession::analyse(const char* name, EDtError &rc)
 583 {
 584    BPTR              fh;
 585    uint8             s[1024];
 586    String            path;
 587    bool              res = true;
 588    String            fileName;
 589    track            *nt = 0;           // new track
 590    index            *idx = 0;
 591
 592    rc = DT_UnableToOpenFile;
 593
 594    _d(Lvl_Info, "%s: starting analysis. File name: %s", (int)__PRETTY_FUNCTION__, (int)name);
 595
 596    fh = DOS->Open(const_cast<char*>(name), MODE_OLDFILE);
 597    if (0 == fh)
 598       return false;
 599
 600    BPTR lock = DOS->ParentOfFH(fh);
 601    DOS->NameFromLock(lock, (char*)s, sizeof(s));
 602    path = (char*)s;
 603
 604    _d(Lvl_Info, "%s: current path for binaries: %s", (int)__PRETTY_FUNCTION__, (int)path.Data());
 605
 606    rc = DT_OK;
 607
 608    while (DOS->FGets(fh, (char*)s, sizeof(s)) != 0)
 609    {
 610       for (int i=0; s[i] != 0; i++)
 611       {
 612          if ((s[i] != 10) && (s[i] != 13) && (s[i] != '\t') && (s[i]<' '))
 613          {
 614             DOS->Close(fh);
 615             return false;
 616          }
 617          if ((s[i] >=128) && (s[i]<160))
 618          {
 619             DOS->Close(fh);
 620             return false;
 621          }
 622       }
 623
 624       String str((char*)s);
 625       VectorT<String> v = str.Explode();
 626
 627       if (v.Count() > 0)
 628       {
 629          str = v[0].UpperCase();
 630
 631          if (str == "TRACK")
 632          {
 633             int32 tn;
 634
 635             _d(Lvl_Info, "%s: parsing track", (int)__PRETTY_FUNCTION__);
 636             if (v[1][0] == '0')
 637                tn = v[1].SubString(1, -1).ToLong();
 638             else
 639                tn = v[1].ToLong();
 640
 641             nt = track::newTrack(tn, v[2]);
 642
 643             if (nt == 0)
 644             {
 645                _d(Lvl_Info, "%s: failed to create track", (int)__PRETTY_FUNCTION__);
 646                rc = DT_FileMalformed;
 647                res = false;
 648                break;
 649             }
 650
 651             tracks << nt;
 652          }
 653          else if (str == "INDEX")
 654          {
 655             int32 tn;
 656
 657             _d(Lvl_Info, "%s: parsing index", (int)__PRETTY_FUNCTION__);
 658             if ((files.Count() == 0) || (nt == 0))
 659             {
 660                _d(Lvl_Info, "%s: files or tracks not defined yet", (int)__PRETTY_FUNCTION__);
 661                rc = DT_FileMalformed;
 662                res = false;
 663                break;
 664             }
 665
 666             uint32 pos = parseLocation(v[2]);
 667             if (idx != 0)
 668                idx->setSecCnt(pos-idx->getLocation());
 669
 670             if (v[1][0] == '0')
 671                tn = v[1].SubString(1, -1).ToLong();
 672             else
 673                tn = v[1].ToLong();
 674
 675            idx = index::newIndex(tn, pos);
 676             nt->addIndex(idx);
 677          }
 678          else if (str == "FILE")
 679          {
 680             file *f;
 681             _d(Lvl_Info, "%s: parsing file", (int)__PRETTY_FUNCTION__);
 682
 683             f = file::newFile(path, v[1], v[2]);
 684             if (f == 0)
 685             {
 686                _d(Lvl_Info, "%s: failed to create file entry for %s", (int)__PRETTY_FUNCTION__, (int)v[1].Data());
 687                rc = DT_UnableToOpenFile;
 688                res = false;
 689                break;
 690             }
 691
 692             files << f;
 693             idx = 0;
 694
 695             if (f->getFileType() != file::Type_Intel)
 696             {
 697                _d(Lvl_Warning, "%s: Unsupported file format: %s", (int)__PRETTY_FUNCTION__, (int)v[2].Data());
 698                rc = DT_FileFormatNotSupported;
 699                res = false;
 700                break;
 701             }
 702          }
 703          else if (str == "FLAGS")
 704          {
 705             _d(Lvl_Info, "%s: flags are not supported at the moment.", (int)__PRETTY_FUNCTION__);
 706             rc = DT_FileFormatNotSupported;
 707             res = false;
 708             break;
 709          }
 710          else if (str == "REM")
 711          {
 712             _d(Lvl_Info, "%s: %s", (int)__PRETTY_FUNCTION__, (int)str.Data());
 713          }
 714          else if (str == "CATALOG")
 715          {
 716             _d(Lvl_Info, "%s: parsing catalog", (int)__PRETTY_FUNCTION__);
 717             catalog = v[1].ToQuad();
 718          }
 719          else if (str == "CDTEXTFILE")
 720          {
 721             _d(Lvl_Warning, "%s: CDTEXTFILE TAG IS NOT SUPPORTED!", (int)__PRETTY_FUNCTION__);
 722          }
 723          else if (str == "ISRC")
 724          {
 725             _d(Lvl_Info, "%s: reading ISRC", (int)__PRETTY_FUNCTION__);
 726             if (0 == nt)
 727             {
 728                rc = DT_FileMalformed;
 729                res = false;
 730                break;
 731             }
 732             nt->setISRC(v[1]);
 733          }
 734          else if (str == "PREGAP")
 735          {
 736             _d(Lvl_Info, "%s: parsing pregap", (int)__PRETTY_FUNCTION__);
 737             if (0 == nt)
 738             {
 739                rc = DT_FileMalformed;
 740                res = false;
 741                break;
 742             }
 743             nt->setPreGap(v[1].ToLong());
 744             _d(Lvl_Info, "%s: pregap size: %ld", (int)__PRETTY_FUNCTION__, v[1].ToLong());
 745          }
 746          else if (str == "POSTGAP")
 747          {
 748             _d(Lvl_Warning, "%s: postgaps not supported", (int)__PRETTY_FUNCTION__);
 749             rc = DT_FileFormatNotSupported;
 750             res = false;
 751             break;
 752          }
 753          else if (str == "ARRANGER")
 754          {
 755             _d(Lvl_Info, "%s: read arranger: %s", (int)__PRETTY_FUNCTION__, (int)v[1].Data());
 756             if (0 != nt)
 757                nt->setArranger(v[1]);
 758             else
 759                arranger = v[1];
 760          }
 761          else if (str == "COMPOSER")
 762          {
 763             _d(Lvl_Info, "%s: read composer: %s", (int)__PRETTY_FUNCTION__, (int)v[1].Data());
 764             if (0 != nt)
 765                nt->setComposer(v[1]);
 766             else
 767                composer = v[1];
 768          }
 769          else if (str == "DISC_ID")
 770          {
 771             _d(Lvl_Warning, "%s: ignoring disc id", (int)__PRETTY_FUNCTION__);
 772             disc_id = v[1];
 773          }
 774          else if (str == "GENRE")
 775          {
 776             _d(Lvl_Warning, "%s: ignoring genre", (int)__PRETTY_FUNCTION__);
 777
 778             // safe to skip this one.
 779          }
 780          else if (str == "MESSAGE")
 781          {
 782             _d(Lvl_Info, "%s: read message: %s", (int)__PRETTY_FUNCTION__, (int)v[1].Data());
 783             if (0 != nt)
 784                nt->setMessage(v[1]);
 785             else
 786                message = v[1];
 787          }
 788          else if (str == "PERFORMER")
 789          {
 790             _d(Lvl_Info, "%s: read performer: %s", (int)__PRETTY_FUNCTION__, (int)v[1].Data());
 791             if (0 != nt)
 792                nt->setPerformer(v[1]);
 793             else
 794                performer = v[1];
 795          }
 796          else if (str == "SONGWRITER")
 797          {
 798             _d(Lvl_Info, "%s: read songwriter: %s", (int)__PRETTY_FUNCTION__, (int)v[1].Data());
 799             if (0 != nt)
 800                nt->setSongWriter(v[1]);
 801             else
 802                songwriter = v[1];
 803          }
 804          else if (str == "TITLE")
 805          {
 806             _d(Lvl_Info, "%s: read title: %s", (int)__PRETTY_FUNCTION__, (int)v[1].Data());
 807             if (0 != nt)
 808                nt->setTitle(v[1]);
 809             else
 810                title = v[1];
 811          }
 812          else if (str == "TOC_INFO")
 813          {
 814             _d(Lvl_Warning, "%s: TOC INFO not supported", (int)__PRETTY_FUNCTION__);
 815             rc = DT_FileFormatNotSupported;
 816             res = false;
 817             break;
 818          }
 819          else if (str == "TOC_INFO2")
 820          {
 821             _d(Lvl_Warning, "%s: TOC INFO not supported", (int)__PRETTY_FUNCTION__);
 822             rc = DT_FileFormatNotSupported;
 823             res = false;
 824             break;
 825          }
 826          else if (str == "UPC_EAN")
 827          {
 828             _d(Lvl_Warning, "%s: ignoring UPC", (int)__PRETTY_FUNCTION__);
 829             upc_ean = v[1];
 830          }
 831          else if (str == "SIZE_INFO")
 832          {
 833             _d(Lvl_Warning, "%s: alien SIZE INFO not supported", (int)__PRETTY_FUNCTION__);
 834             rc = DT_FileFormatNotSupported;
 835             res = false;
 836             break;
 837          }
 838          else
 839          {
 840             _d(Lvl_Error, "%s: Malformed tag %s. Aborting.", (int)__PRETTY_FUNCTION__, (int)v[0].Data());
 841             rc = DT_FileMalformed;
 842             res = false;
 843             break;
 844          }
 845       }
 846
 847    }
 848
 849    if (tracks.Count() == 0)
 850    {
 851       rc = DT_FileMalformed;
 852       res = false;
 853    }
 854
 855    for (int32 i=0; i<tracks.Count(); i++)
 856    {
 857       if (tracks[i]->getIndexCount() == 0)
 858       {
 859          res = false;
 860          rc = DT_FileMalformed;
 861          break;
 862       }
 863    }
 864
 865    _d(Lvl_Info, "%s: fixing references...", (int)__PRETTY_FUNCTION__);
 866
 867    if (res == true)
 868    {
 869       uint32 len_so_far = 0;
 870       int32 sec_so_far = -150;
 871       int32 fno = 0;
 872
 873       if ((tracks[0]->getIndex(0)->getNumber() != 0) && (tracks[0]->getPreGap() < 150))
 874          tracks[0]->setPreGap(150);
 875
 876       for (int32 i=0; i<tracks.Count(); i++)
 877       {
 878          _d(Lvl_Info, "%s: Advancing to track %ld", (int)__PRETTY_FUNCTION__, i+1);
 879          track *t = tracks[i];
 880
 881          sec_so_far += t->getPreGap();
 882
 883          for (int32 j=0; j<t->getIndexCount(); j++)
 884          {
 885             _d(Lvl_Info, "%s: Checking index %ld", (int)__PRETTY_FUNCTION__, j+1);
 886             index *x = t->getIndex(j);
 887
 888             if ((x->getNumber() == 0) && (t->getPreGap() != 0))
 889             {
 890                _d(Lvl_Warning, "%s: CUE specifies both pregap and index 0, it's a nonsense.", (int32)__PRETTY_FUNCTION__);
 891                rc = DT_FileMalformed;
 892                res = false;
 893                break;
 894             }
 895
 896             x->setLocation(sec_so_far);
 897             x->setFile(files[fno]);
 898             x->setFileOffset(len_so_far);
 899
 900             if (x->getSecCnt() == 0xffffffff)
 901             {
 902                _d(Lvl_Info, "%s: Altering index accordingly to track %ld", (int)__PRETTY_FUNCTION__, fno+1);
 903                x->setSecCnt((files[fno]->getFileSize() - len_so_far) / t->getSectorSize());
 904                x->setDataLength(x->getSecCnt() * t->getSectorSize());
 905
 906                fno++;
 907                len_so_far = 0;
 908             }
 909             else
 910             {
 911                x->setDataLength(x->getSecCnt() * t->getSectorSize());
 912                len_so_far += x->getSecCnt() * t->getSectorSize();
 913             }
 914
 915             sec_so_far += x->getSecCnt();
 916          }
 917
 918          sec_so_far += t->getPostGap();
 919
 920          if (res == false)
 921             break;
 922       }
 923    }
 924
 925    for (int32 i=0; i<tracks.Count(); i++)
 926       tracks[i]->debug(getDebug());
 927
 928    DOS->Close(fh);
 929    return res;
 930 }
 931
 932 uint32               rCUESession::parseLocation(String &s)
 933 {
 934    /*
 935     * NOTE:
 936     * despite MSF holds LBA+150 in normal case,
 937     * we are actually referring to data stored in a file
 938     * thus there is no decrement!
 939     */
 940
 941    String c = s;
 942    int i = 0;
 943    uint32 loc = 0;
 944    uint32 tot = 0;
 945
 946    while ((c[i] != ':') && (i < c.Length()))
 947    {
 948       loc = 10 * loc + c[i]-'0';
 949       i++;
 950    }
 951
 952    tot = loc * 60;
 953    loc = 0;
 954    i++;
 955
 956    while ((c[i] != ':') && (i < c.Length()))
 957    {
 958       loc = 10 * loc + c[i]-'0';
 959       i++;
 960    }
 961
 962    tot = (tot + loc) * 75;
 963    loc = 0;
 964    i++;
 965
 966    while ((c[i] != ':') && (i < c.Length()))
 967    {
 968       loc = 10 * loc + c[i]-'0';
 969       i++;
 970    }
 971
 972    tot  = tot + loc;
 973
 974    _d(Lvl_Info, "%s: Location parsed - %s = %ld", (int)__PRETTY_FUNCTION__, (int)s.Data(), tot);
 975
 976    return tot;
 977 }
 978
 979 void                 rCUESession::cleanUp()
 980 {
 981 }
 982
 983 void                 rCUESession::dispose()
 984 {
 985    delete this;
 986 }
 987
 988 bool                 rCUESession::isAudio()
 989 {
 990    return static_isAudio();
 991 }
 992
 993 bool                 rCUESession::isData()
 994 {
 995    return static_isData();
 996 }
 997
 998 bool                 rCUESession::fillOptItem(IOptItem *disc)
 999 {
1000
1001    if (disc->getItemType() != Item_Disc)
1002       return false;
1003
1004    disc->setFlags(DIF_Disc_MasterizeCD | DIF_Disc_CloseDisc);
1005    IOptItem *sess = disc->addChild();
1006
1007    sess->setCDTDirector(arranger);
1008    sess->setCDTComposer(composer);
1009    sess->setCDTArtist(performer);
1010    sess->setCDTMessage(message);
1011    sess->setCDTTitle(title);
1012    sess->setCDTLyrics(songwriter);
1013
1014    for (int i=0; i<tracks.Count(); i++)
1015    {
1016       IOptItem *trak = sess->addChild();
1017       tracks[i]->fillItem(trak);
1018    }
1019    return true;
1020 }
1021
1022 const char          *rCUESession::getTrackName()
1023 {
1024    return static_getName();
1025 }
1026
1027 uint32               rCUESession::getBlockCount()
1028 {
1029    return blockCount;
1030 }
1031
1032 uint16               rCUESession::getBlockSize()
1033 {
1034    return blockSize;
1035 }
1036
1037 const char          *rCUESession::static_getName()
1038 {
1039    return "CUE Sheet Session";
1040 }
1041
1042 bool                 rCUESession::static_isAudio()
1043 {
1044    return false;
1045 }
1046
1047 bool                 rCUESession::static_isData()
1048 {
1049    return false;
1050 }
1051
1052 bool                 rCUESession::static_isSession()
1053 {
1054    return true;
1055 }
1056
1057 bool                 rCUESession::checkFile(const char* file, EDtError &rc)
1058 {
1059    BPTR  fh;
1060    uint8 s[1024];
1061    int   res = true;
1062
1063    rc = DT_UnableToOpenFile;
1064
1065    fh = DOS->Open(const_cast<char*>(file), MODE_OLDFILE);
1066    if (0 == fh)
1067       return false;
1068
1069    rc = DT_OK;
1070
1071    while (DOS->FGets(fh, (char*)s, sizeof(s)) != 0)
1072    {
1073       for (int i=0; s[i] != 0; i++)
1074       {
1075          if ((s[i] != 10) && (s[i] != 13) && (s[i] != '\t') && (s[i]<' '))
1076          {
1077             DOS->Close(fh);
1078             rc = DT_FileMalformed;
1079             return false;
1080          }
1081          if ((s[i] >=128) && (s[i]<160))
1082          {
1083             DOS->Close(fh);
1084             rc = DT_FileMalformed;
1085             return false;
1086          }
1087       }
1088
1089       String str((char*)s);
1090       VectorT<String> v = str.Explode();
1091
1092       if (v.Count() > 0)
1093       {
1094          str = v[0].UpperCase();
1095
1096          if ((str == "TRACK") ||
1097              (str == "INDEX") ||
1098              (str == "FILE") ||
1099              (str == "FLAGS") ||
1100              (str == "REM") ||
1101              (str == "CATALOG") ||
1102              (str == "CDTEXTFILE") ||
1103              (str == "ISRC") ||
1104              (str == "POSTGAP") ||
1105              (str == "PREGAP") ||
1106              (str == "ARRANGER") ||
1107              (str == "COMPOSER") ||
1108              (str == "DISC_ID") ||
1109              (str == "GENRE") ||
1110              (str == "MESSAGE") ||
1111              (str == "PERFORMER") ||
1112              (str == "SONGWRITER") ||
1113              (str == "TITLE") ||
1114              (str == "TOC_INFO") ||
1115              (str == "TOC_INFO2") ||
1116              (str == "UPC_EAN") ||
1117              (str == "SIZE_INFO"))
1118          {
1119             continue;
1120          }
1121          else
1122          {
1123             rc = DT_FileMalformed;
1124             res = false;
1125             break;
1126          }
1127       }
1128
1129    }
1130
1131    DOS->Close(fh);
1132    return res;
1133 }
1134
1135 DbgHandler*          rCUESession::getDebug()
1136 {
1137    return dbg;
1138 }
1139
1140 void                 rCUESession::setDebug(DbgHandler* nd)
1141 {
1142    dbg = nd;
1143 }
1144