FryingPan/DTLib/rNRGSession.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 "rNRGSession.h"
  21 #include <Generic/LibrarySpool.h>
  22 #include <libclass/dos.h>
  23 #include <Optical/IOptItem.h>
  24 #include "Main.h"
  25
  26 #ifndef MAKE_ID
  27 #define MAKE_ID(a,b,c,d)  ((((ULONG)(a)) << 24) | \
  28                            (((ULONG)(b)) << 16) | \
  29                            (((ULONG)(c)) <<  8) | \
  30                            (((ULONG)(d)) <<  0))
  31 #endif
  32
  33 class file
  34 {
  35 public:
  36    enum filetype
  37    {
  38       Type_Unknown,
  39       Type_Intel,
  40       Type_Motorola,
  41       Type_Wave,
  42       Type_AIFF,
  43       Type_MP3
  44    };
  45
  46 protected:
  47    String            filename;
  48    BPTR              fileptr;
  49
  50 private:
  51    file()
  52    {
  53       fileptr = 0;
  54       filename = "";
  55    };
  56
  57    file(const file&) {};
  58
  59 public:
  60
  61    static file *newFile(const String &filename)
  62    {
  63       BPTR           fileptr;
  64       file          *f;
  65
  66       fileptr = DOS->Open(filename.Data(), MODE_OLDFILE);
  67       if (fileptr == 0)
  68          return 0;
  69
  70       f = new file;
  71       f->filename = filename;
  72       f->fileptr = fileptr;
  73
  74       return f;
  75    }
  76
  77    ~file()
  78    {
  79       if (fileptr != 0)
  80          DOS->Close(fileptr);
  81       fileptr = 0;
  82    }
  83
  84    const String& getFileName() const
  85    {
  86       return filename;
  87    }
  88
  89    void seek(uint32 offset) const
  90    {
  91       DOS->Seek(fileptr, offset, OFFSET_BEGINNING);
  92    }
  93
  94    uint32 read(void* mem, uint32 len) const
  95    {
  96       return DOS->Read(fileptr, mem, len);
  97    }
  98
  99    BPTR getBPTR() const
 100    {
 101       return fileptr;
 102    }
 103 };
 104
 105 class index
 106 {
 107    uint16            num;     // index number
 108    uint32            loc;     // boundary: start
 109    uint32            cnt;     // and count
 110
 111    index()
 112    {
 113       num = 0;
 114       loc = 0;
 115       cnt = 0;
 116    }
 117 public:
 118
 119    static index *newIndex(uint16 number, uint32 location)
 120    {
 121       index *i = new index();
 122
 123       i->num = (number >> 4) * 10 + (number & 15);
 124       i->loc = location;
 125       i->cnt = 0xffffffff;
 126
 127       return i;
 128    }
 129
 130    void setEndAddress(uint32 scnt)
 131    {
 132       cnt = scnt - loc;
 133    }
 134
 135    uint32 getSecCnt() const
 136    {
 137       return cnt;
 138    }
 139
 140    uint32 getLocation() const
 141    {
 142       return loc;
 143    }
 144
 145    void setLocation(uint32 l)
 146    {
 147       loc = l;
 148    }
 149
 150    uint32 getNumber() const
 151    {
 152       return num;
 153    }
 154
 155    void fillItem(IOptItem* item)
 156    {
 157       item->setStartAddress(loc);
 158       item->setItemNumber(num);
 159       item->setDataBlockCount(cnt);
 160    }
 161
 162    bool isValid() const
 163    {
 164       return (cnt != 0);
 165    }
 166 };
 167
 168 class track
 169 {
 170    EDataType         type;          // type of data
 171    uint32            flags;         // additional flags (like "RAW")
 172    uint16            secsize;       // resulting from the two above fields
 173    uint16            pregap;        // in sectors
 174    String            isrc;          // ISRC number
 175    int16             number;        // track number
 176    VectorT<index*>   indices;       // indices
 177
 178    String            arranger;      // CDText
 179    String            composer;
 180    String            performer;
 181    String            message;
 182    String            title;
 183    String            songwriter;
 184
 185    uint64            filepos;
 186    uint64            length;
 187    int64             currpos;
 188
 189    file             *f;
 190
 191    track()
 192    {
 193       type = Data_Unknown;
 194       flags = 0;
 195       secsize = 2352;
 196       pregap = 0;
 197       number = 0;
 198    };
 199
 200 public:
 201    static track* newTrack(file *f, int32 num)
 202    {
 203       track *nt = new track;
 204       nt->f = f;
 205       nt->number = (num >> 4) * 10 + (num & 15);
 206       return nt;
 207    }
 208
 209    const file *getFile() const
 210    {
 211       return f;
 212    }
 213
 214    void setType(EDataType dt)
 215    {
 216       type = dt;
 217    }
 218
 219    void setSectorSize(uint16 size)
 220    {
 221       secsize = size;
 222    }
 223
 224    void setDataStart(uint64 pos)
 225    {
 226       filepos = pos;
 227    }
 228
 229    void setDataEnd(uint64 pos)
 230    {
 231       length = pos - filepos;
 232    }
 233
 234    void setDataMode2(uint8 mode)
 235    {
 236    }
 237
 238    EDataType getType() const
 239    {
 240       return type;
 241    }
 242
 243    void debug(DbgHandler *__dbg)
 244    {
 245       if (__dbg == 0)
 246          return;
 247
 248       _D(Lvl_Info, "Number:          %ld", number);
 249       _D(Lvl_Info, "File type:       %ld", type);
 250       _D(Lvl_Info, "Flags:           %ld", flags);
 251       _D(Lvl_Info, "Sector Size:     %ld", secsize);
 252       _D(Lvl_Info, "PreGap:          %ld", pregap);
 253       _D(Lvl_Info, "ISRC:            %s", (int32)isrc.Data());
 254       _D(Lvl_Info, "Arranger:        %s", (int32)arranger.Data());
 255       _D(Lvl_Info, "Composer:        %s", (int32)composer.Data());
 256       _D(Lvl_Info, "Performer:       %s", (int32)performer.Data());
 257       _D(Lvl_Info, "Message:         %s", (int32)message.Data());
 258       _D(Lvl_Info, "Title:           %s", (int32)title.Data());
 259       _D(Lvl_Info, "Song Writer:     %s", (int32)songwriter.Data());
 260
 261       _D(Lvl_Info, "===");
 262    }
 263
 264    void setArranger(const String &s)
 265    {
 266       arranger = s;
 267    }
 268
 269    void setComposer(const String &s)
 270    {
 271       composer = s;
 272    }
 273
 274    void setPerformer(const String &s)
 275    {
 276       performer = s;
 277    }
 278
 279    void setMessage(const String &s)
 280    {
 281       message = s;
 282    }
 283
 284    void setTitle(const String &s)
 285    {
 286       title = s;
 287    }
 288
 289    void setSongWriter(const String &s)
 290    {
 291       songwriter = s;
 292    }
 293
 294    void setPreGap(int32 gap)
 295    {
 296       pregap = gap;
 297    }
 298
 299    int32 getPreGap() const
 300    {
 301       return pregap;
 302    }
 303
 304    int32 getNumber() const
 305    {
 306       return number;
 307    }
 308
 309    void setISRC(const String &s)
 310    {
 311       isrc = s;
 312    }
 313
 314    void addIndex(index *i)
 315    {
 316       indices << i;
 317    }
 318
 319    index *getIndex(int32 i)
 320    {
 321       return indices[i];
 322    }
 323
 324    int32 getIndexCount()
 325    {
 326       return indices.Count();
 327    }
 328
 329    int32 getSectorSize() const
 330    {
 331       return secsize;
 332    }
 333
 334    void fillItem(IOptItem *item)
 335    {
 336       uint32 len = 0;
 337
 338       item->setCDTDirector(arranger);
 339       item->setCDTComposer(composer);
 340       item->setCDTArtist(performer);
 341       item->setCDTMessage(message);
 342       item->setCDTTitle(title);
 343       item->setCDTLyrics(songwriter);
 344       item->setFlags(flags);
 345       item->setSectorSize(secsize);
 346       item->setPreGapSize(pregap);
 347       item->setItemNumber(number);
 348       item->setDataType(type);
 349       item->setSectorSize(secsize);
 350
 351       item->setStartAddress(indices[0]->getLocation() - pregap);
 352       for (int32 i=0; i<indices.Count(); i++)
 353       {
 354          if (indices[i]->isValid() == false)
 355             continue;
 356
 357          IOptItem *indx = item->addChild();
 358
 359          indices[i]->fillItem(indx);
 360          len += indices[i]->getSecCnt();
 361       }
 362       item->setDataBlockCount(len);
 363    }
 364
 365    void setUp()
 366    {
 367       currpos = -1;
 368    }
 369
 370    uint32 read(void* &mem, uint32 len)
 371    {
 372       len *= secsize;
 373
 374       if (currpos == -1)
 375       {
 376          f->seek(filepos);
 377          currpos = 0;
 378       }
 379       else if ((uint64)currpos >= length)
 380          return 0;
 381
 382       len = len < (length - currpos) ? len : (length - currpos);
 383       f->read(mem, len);
 384       mem = &((char*)mem)[len];
 385       currpos += len;
 386
 387       return len / secsize;
 388    }
 389 };
 390
 391
 392
 393 struct nrg_etnf
 394 {
 395    uint32   start;
 396    uint32   length;
 397    uint32   type;       // 0 = mode1, 1 = ?, 2 = mode2form1, 3 = mixed mode2
 398    uint32   secpos;     // without pregaps
 399    uint32   dummy;      // whatever.
 400 };
 401
 402 struct nrg_etn2
 403 {
 404    uint64   start;
 405    uint64   length;
 406    uint32   type;
 407    uint32   secpos;     // as above
 408    uint64   dummy;
 409 };
 410
 411 struct nrg_cuex
 412 {
 413    uint8    adr_ctl;    //
 414    uint8    track;      // BCD track number
 415    uint8    index;      // index (bcd?)
 416    uint8    res;        // ???
 417    uint32   sector;     // ...
 418 };
 419
 420 struct nrg_daoi
 421 {
 422    uint32   dummy;
 423    uint8    mcn[14];
 424    uint8    disc_mode;
 425    uint8    one1;
 426    uint8    first_track;
 427    uint8    last_track;
 428    struct dao_track
 429    {
 430       uint8    pad[12];
 431       uint16   secsize;
 432       uint8    mode;
 433       uint8    zero1;
 434       uint8    zero2;
 435       uint8    type;
 436       uint32   pregap;
 437       uint32   offset;
 438       uint32   end;
 439    }        track[0];
 440 };
 441
 442 struct nrg_daox
 443 {
 444    uint32   dummy;
 445    uint8    mcn[14];
 446    uint8    disc_mode;
 447    uint8    one1;
 448    uint8    first_track;
 449    uint8    last_track;
 450    struct dao_track
 451    {
 452       uint8    pad[12];
 453       uint16   secsize;
 454       uint8    mode;
 455       uint8    zero1;
 456       uint8    zero2;
 457       uint8    type;
 458       uint64   pregap;        // pregap data start
 459       uint64   offset;        // normal data start
 460       uint64   end;           // normal data end
 461    }        track[0];
 462 };
 463
 464
 465                      rNRGSession::rNRGSession(const char* sFileName, EDtError &rc)
 466 {
 467    _createDebug(true, "rNRGSession");
 468    name = sFileName;
 469    f    = 0;
 470    analyse(sFileName, rc);
 471 }
 472
 473                      rNRGSession::~rNRGSession()
 474 {
 475    tracks.ForEach(&freeTrack);
 476
 477    if (f != 0)
 478       delete f;
 479    f = 0;
 480
 481    _destroyDebug();
 482 }
 483
 484 bool                 rNRGSession::freeTrack(track* const& t)
 485 {
 486    delete t;
 487    return true;
 488 }
 489
 490 IFileReader*         rNRGSession::openRead(const char* sFile, EDtError &rc)
 491 {
 492    IFileReader *out = 0;
 493
 494    checkFile(sFile, rc);
 495    if (rc == DT_OK)
 496    {
 497       out = new rNRGSession(sFile, rc);
 498       if (rc != DT_OK)
 499       {
 500          out->dispose();
 501          out = 0;
 502       }
 503    }
 504    return out;
 505 }
 506
 507 const char*          rNRGSession::getName()
 508 {
 509    return static_getName();
 510 }
 511
 512 bool                 rNRGSession::readData(const IOptItem* item, void* mem, int len)
 513 {
 514    _d(Lvl_Info, "%s: reading -> %08lx, %ld, curr trk: %ld; bptr=%lx", (int)__PRETTY_FUNCTION__, (int)mem, len, currtrk, (int)tracks[currtrk]->getFile()->getBPTR());
 515
 516    if (item->getItemType() != Item_Track)
 517    {
 518       int32 ret;
 519
 520       if (currtrk == tracks.Count())
 521          return false;
 522
 523       ret = tracks[currtrk]->read(mem, len);
 524       if (ret == len)
 525          return true;
 526
 527       currtrk++;
 528       ret += readData(item, mem, len-ret);
 529
 530       return true;
 531    }
 532    else
 533    {
 534       ASSERTS(false, "Functionality not yet implemented, sorry.");
 535       return false;
 536    }
 537 }
 538
 539 bool                 rNRGSession::setUp()
 540 {
 541    _d(Lvl_Info, "%s: seeking all items to the start position...", (int)__PRETTY_FUNCTION__);
 542
 543    for (int i=0; i<tracks.Count(); i++)
 544       tracks[i]->setUp();
 545
 546
 547    f->seek(0);
 548
 549    currtrk = 0;
 550
 551    return true;
 552 }
 553
 554 bool                 rNRGSession::analyse(const char* name, EDtError &rc)
 555 {
 556    BPTR fh;
 557    bool res=true;
 558    uint32 data;
 559    uint32 size;
 560    nrg_cuex *cue1 = 0;
 561    nrg_daoi *dao1 = 0;
 562    nrg_daox *dao2 = 0;
 563
 564    rc = DT_UnableToOpenFile;
 565
 566    fh = DOS->Open(name, MODE_OLDFILE);
 567    if (fh == 0)
 568       return false;
 569
 570    f = file::newFile(name);
 571
 572    rc = DT_OK;
 573
 574    DOS->Seek(fh, -4, OFFSET_END);
 575    DOS->Read(fh, &data, 4);
 576
 577    data = L2BE(data);
 578    DOS->Seek(fh, data, OFFSET_BEGINNING);
 579
 580    do
 581    {
 582       DOS->Read(fh, &data, 4);
 583       DOS->Read(fh, &size, 4);
 584       data = L2BE(data);
 585       size = L2BE(size);
 586       if (data == MAKE_ID('C','D','T','X'))
 587       {
 588          _d(Lvl_Info, "%s: CDTX Tag", (int)__PRETTY_FUNCTION__);
 589          DOS->Seek(fh, size, OFFSET_CURRENT);
 590       }
 591       else if (data == MAKE_ID('C','U','E','X'))
 592       {
 593          _d(Lvl_Info, "%s: CUEX Tag", (int)__PRETTY_FUNCTION__);
 594          cue1 = (nrg_cuex*)new char[size];
 595          DOS->Read(fh, cue1, size);
 596       }
 597       else if (data == MAKE_ID('C','U','E','S'))
 598       {
 599          _d(Lvl_Info, "%s: CUES Tag", (int)__PRETTY_FUNCTION__);
 600          DOS->Seek(fh, size, OFFSET_CURRENT);
 601       }
 602       else if (data == MAKE_ID('D','A','O','X'))
 603       {
 604          _d(Lvl_Info, "%s: DAOX Tag", (int)__PRETTY_FUNCTION__);
 605          dao2 = (nrg_daox*)new char[size];
 606          DOS->Read(fh, dao2, size);
 607       }
 608       else if (data == MAKE_ID('D','A','O','I'))
 609       {
 610          _d(Lvl_Info, "%s: DAOI Tag", (int)__PRETTY_FUNCTION__);
 611          dao1 = (nrg_daoi*)new char[size];
 612          DOS->Read(fh, dao1, size);
 613
 614          _d(Lvl_Info, "%s: DAOI: ftrk=%ld, ltrk=%ld", (int)__PRETTY_FUNCTION__, dao1->first_track, dao1->last_track);
 615          _d(Lvl_Info, "%s: DAOI: MCN=%02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx", (int)__PRETTY_FUNCTION__, dao1->mcn[0], dao1->mcn[1], dao1->mcn[2], dao1->mcn[3], dao1->mcn[4], dao1->mcn[5], dao1->mcn[6], dao1->mcn[7], dao1->mcn[8], dao1->mcn[9], dao1->mcn[10], dao1->mcn[11], dao1->mcn[12], dao1->mcn[13]);
 616
 617          for (int i=0; i<=(dao1->last_track-dao1->first_track); i++)
 618          {
 619             _d(Lvl_Info, "%s: DAOI: track=%ld secsize=%ld mode=%ld type=%ld pregap=%lx data=%lx end=%lx",
 620                   (int)__PRETTY_FUNCTION__,
 621                   i+dao1->first_track,
 622                   dao1->track[i].secsize,
 623                   dao1->track[i].mode,
 624                   dao1->track[i].type,
 625                   dao1->track[i].pregap,
 626                   dao1->track[i].offset,
 627                   dao1->track[i].end);
 628          }
 629       }
 630       else if (data == MAKE_ID('E','T','N','F'))
 631       {
 632          _d(Lvl_Info, "%s: ETNF Tag", (int)__PRETTY_FUNCTION__);
 633          int32 num = (size / sizeof(nrg_etnf));
 634          nrg_etnf *etnf = (nrg_etnf*)new char[size];
 635          DOS->Read(fh, etnf, size);
 636
 637          for (int i=0; i<num; i++)
 638          {
 639             _d(Lvl_Info, "%s: ETNF: start=%ld length=%ld type=%ld sector=%ld other=%lx", (int)__PRETTY_FUNCTION__, etnf[i].start, etnf[i].length, etnf[i].type, etnf[i].secpos, etnf[i].dummy);
 640          }
 641
 642          delete etnf;
 643       }
 644       else if (data == MAKE_ID('E','T','N','2'))
 645       {
 646          _d(Lvl_Info, "%s: ETN2 Tag", (int)__PRETTY_FUNCTION__);
 647          int32 num = (size / sizeof(nrg_etn2));
 648          nrg_etn2 *etnf = (nrg_etn2*)new char[size];
 649          DOS->Read(fh, etnf, size);
 650
 651          for (int i=0; i<num; i++)
 652          {
 653             _d(Lvl_Info, "%s: ETN2: start=%ld length=%ld type=%ld sector=%ld other=%lx", (int)__PRETTY_FUNCTION__, etnf[i].start, etnf[i].length, etnf[i].type, etnf[i].secpos, etnf[i].dummy);
 654          }
 655
 656          delete etnf;
 657       }
 658       else if (data == MAKE_ID('N','E','R','O'))
 659       {
 660          _d(Lvl_Info, "%s: NERO Tag", (int)__PRETTY_FUNCTION__);
 661          DOS->Seek(fh, size, OFFSET_CURRENT);
 662       }
 663       else if (data == MAKE_ID('N','E','R','5'))
 664       {
 665          _d(Lvl_Info, "%s: NER5 Tag", (int)__PRETTY_FUNCTION__);
 666          DOS->Seek(fh, size, OFFSET_CURRENT);
 667       }
 668       else if (data == MAKE_ID('S','I','N','F'))
 669       {
 670          _d(Lvl_Info, "%s: SINF Tag", (int)__PRETTY_FUNCTION__);
 671          DOS->Seek(fh, size, OFFSET_CURRENT);
 672       }
 673       else if (data == MAKE_ID('M','T','Y','P'))
 674       {
 675          _d(Lvl_Info, "%s: MTYP Tag", (int)__PRETTY_FUNCTION__);
 676          DOS->Seek(fh, size, OFFSET_CURRENT);
 677       }
 678       else if (data == MAKE_ID('E','N','D','!'))
 679       {
 680          _d(Lvl_Info, "%s: END! Tag", (int)__PRETTY_FUNCTION__);
 681          break;
 682       }
 683
 684    }
 685    while (true);
 686
 687    if (res == true)
 688       res = buildTrackList(cue1, rc);
 689    if ((dao2 != 0) && (res == true))
 690       res = updateTrackData(dao2, rc);
 691    if ((dao1 != 0) && (res == true))
 692       res = updateTrackData(dao2, rc);
 693
 694    if (0 != cue1)
 695       delete cue1;
 696    if (0 != dao1)
 697       delete dao1;
 698    if (0 != dao2)
 699       delete dao2;
 700
 701    DOS->Close(fh);
 702    return res;
 703 }
 704
 705 bool                 rNRGSession::buildTrackList(nrg_cuex *cue, EDtError &rc)
 706 {
 707    if (cue == 0)
 708    {
 709       rc = DT_FileFormatNotSupported;
 710       return false;
 711    }
 712
 713    for (int i=0;; i++)
 714    {
 715       track *t = 0;
 716       index *x = 0;
 717
 718       _d(Lvl_Info, "%s: CUEX: type=%02lx track=%02lx adrctl=%02lx res=%02lx sector=%08lx", (int)__PRETTY_FUNCTION__, cue[i].adr_ctl, cue[i].track, cue[i].index, cue[i].res, cue[i].sector);
 719
 720       if (cue[i].track == 0)
 721          continue;
 722
 723       if (tracks.Count() > 0)
 724          tracks[-1]->getIndex(-1)->setEndAddress(cue[i].sector);
 725
 726       if (cue[i].track == 0xaa)
 727          break;
 728
 729       for (int j=0; j<tracks.Count(); j++)
 730       {
 731          if (tracks[j]->getNumber() == ((cue[i].track >> 4) * 10 + (cue[i].track & 15)))
 732          {
 733             t = tracks[j];
 734             break;
 735          }
 736       }
 737
 738       if (t == 0)
 739       {
 740          t = track::newTrack(f, cue[i].track);
 741          tracks << t;
 742
 743          switch (cue[i].adr_ctl & 0xc0)
 744          {
 745             case 0x40:
 746                t->setType(Data_Mode1);
 747                break;
 748             case 0x00:
 749                t->setType(Data_Audio);
 750                break;
 751             default:
 752                rc = DT_FileFormatNotSupported;
 753                return false;
 754          }
 755       }
 756
 757       x = index::newIndex(cue[i].index, cue[i].sector);
 758       t->addIndex(x);
 759
 760    }
 761
 762    return true;
 763 }
 764
 765 bool                 rNRGSession::updateTrackData(struct nrg_daox* dao, EDtError &rc)
 766 {
 767    if (dao == 0)
 768    {
 769       rc = DT_FileFormatNotSupported;
 770       return false;
 771    }
 772
 773    _d(Lvl_Info, "%s: DAO: ftrk=%ld, ltrk=%ld", (int)__PRETTY_FUNCTION__, dao->first_track, dao->last_track);
 774    _d(Lvl_Info, "%s: DAO: MCN=%02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx", (int)__PRETTY_FUNCTION__, dao->mcn[0], dao->mcn[1], dao->mcn[2], dao->mcn[3], dao->mcn[4], dao->mcn[5], dao->mcn[6], dao->mcn[7], dao->mcn[8], dao->mcn[9], dao->mcn[10], dao->mcn[11], dao->mcn[12], dao->mcn[13]);
 775
 776    for (int i=0; i<=(dao->last_track-dao->first_track); i++)
 777    {
 778       track *t = 0;
 779
 780       _d(Lvl_Info, "%s: DAO: track=%ld secsize=%ld mode=%ld type=%ld pregap=%lx data=%lx end=%lx",
 781             (int)__PRETTY_FUNCTION__,
 782             i+dao->first_track,
 783             dao->track[i].secsize,
 784             dao->track[i].mode,
 785             dao->track[i].type,
 786             dao->track[i].pregap,
 787             dao->track[i].offset,
 788             dao->track[i].end);
 789
 790       for (int j=0; j<tracks.Count(); j++)
 791       {
 792          if (tracks[j]->getNumber() == (i + dao->first_track))
 793          {
 794             t = tracks[j];
 795             break;
 796          }
 797       }
 798
 799       if (t == 0)
 800       {
 801          rc = DT_FileMalformed;
 802          return false;
 803       }
 804
 805       t->setSectorSize(dao->track[i].secsize);
 806       switch (dao->track[i].mode)
 807       {
 808          case 0:
 809             t->setType(Data_Mode1);
 810             break;
 811          case 1:
 812             t->setType(Data_Mode2Form1);
 813             break;
 814          case 2:
 815             t->setType(Data_Mode2Form2);
 816             break;
 817          case 3:
 818          case 6:
 819             t->setType(Data_Mode2);
 820             break;
 821          case 7:
 822             t->setType(Data_Audio);
 823             break;
 824          default:
 825             rc = DT_FileFormatNotSupported;
 826             return false;
 827       }
 828       t->setDataStart(dao->track[i].pregap);
 829       t->setDataEnd(dao->track[i].end);
 830       t->setDataMode2(dao->track[i].mode);
 831
 832       _d(Lvl_Info, "%s: Track %ld: %ld - %ld, mode %ld", (int)__PRETTY_FUNCTION__, i, dao->track[i].pregap, dao->track[i].end, dao->track[i].mode);
 833    }
 834    return true;
 835 }
 836
 837 bool                 rNRGSession::updateTrackData(struct nrg_daoi* dao, EDtError &rc)
 838 {
 839    if (dao == 0)
 840    {
 841       rc = DT_FileFormatNotSupported;
 842       return false;
 843    }
 844
 845    _d(Lvl_Info, "%s: DAO: ftrk=%ld, ltrk=%ld", (int)__PRETTY_FUNCTION__, dao->first_track, dao->last_track);
 846    _d(Lvl_Info, "%s: DAO: MCN=%02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx %02lx", (int)__PRETTY_FUNCTION__, dao->mcn[0], dao->mcn[1], dao->mcn[2], dao->mcn[3], dao->mcn[4], dao->mcn[5], dao->mcn[6], dao->mcn[7], dao->mcn[8], dao->mcn[9], dao->mcn[10], dao->mcn[11], dao->mcn[12], dao->mcn[13]);
 847
 848    for (int i=0; i<=(dao->last_track-dao->first_track); i++)
 849    {
 850       track *t = 0;
 851
 852       _d(Lvl_Info, "%s: DAO: track=%ld secsize=%ld mode=%ld type=%ld pregap=%lx data=%lx end=%lx",
 853             (int)__PRETTY_FUNCTION__,
 854             i+dao->first_track,
 855             dao->track[i].secsize,
 856             dao->track[i].mode,
 857             dao->track[i].type,
 858             dao->track[i].pregap,
 859             dao->track[i].offset,
 860             dao->track[i].end);
 861
 862       for (int j=0; j<tracks.Count(); j++)
 863       {
 864          if (tracks[j]->getNumber() == (i + dao->first_track))
 865          {
 866             t = tracks[j];
 867             break;
 868          }
 869       }
 870
 871       if (t == 0)
 872       {
 873          rc = DT_FileMalformed;
 874          return false;
 875       }
 876
 877       t->setSectorSize(dao->track[i].secsize);
 878       switch (dao->track[i].mode)
 879       {
 880          case 0:
 881             t->setType(Data_Mode1);
 882             break;
 883          case 1:
 884             t->setType(Data_Mode2Form1);
 885             break;
 886          case 2:
 887             t->setType(Data_Mode2Form2);
 888             break;
 889          case 3:
 890          case 6:
 891             t->setType(Data_Mode2);
 892             break;
 893          case 7:
 894             t->setType(Data_Audio);
 895             break;
 896          default:
 897             rc = DT_FileFormatNotSupported;
 898             return false;
 899       }
 900       t->setDataStart(dao->track[i].pregap);
 901       t->setDataEnd(dao->track[i].end);
 902       t->setDataMode2(dao->track[i].mode);
 903    }
 904    return true;
 905 }
 906
 907 void                 rNRGSession::cleanUp()
 908 {
 909 }
 910
 911 void                 rNRGSession::dispose()
 912 {
 913    delete this;
 914 }
 915
 916 bool                 rNRGSession::isAudio()
 917 {
 918    return static_isAudio();
 919 }
 920
 921 bool                 rNRGSession::isData()
 922 {
 923    return static_isData();
 924 }
 925
 926 bool                 rNRGSession::fillOptItem(IOptItem *disc)
 927 {
 928
 929    if (disc->getItemType() != Item_Disc)
 930       return false;
 931
 932    disc->setFlags(DIF_Disc_MasterizeCD | DIF_Disc_CloseDisc);
 933    IOptItem *sess = disc->addChild();
 934
 935    sess->setCDTDirector(arranger);
 936    sess->setCDTComposer(composer);
 937    sess->setCDTArtist(performer);
 938    sess->setCDTMessage(message);
 939    sess->setCDTTitle(title);
 940    sess->setCDTLyrics(songwriter);
 941
 942    for (int i=0; i<tracks.Count(); i++)
 943    {
 944       IOptItem *trak = sess->addChild();
 945       tracks[i]->fillItem(trak);
 946    }
 947    return true;
 948 }
 949
 950 const char          *rNRGSession::getTrackName()
 951 {
 952    return static_getName();
 953 }
 954
 955 uint32               rNRGSession::getBlockCount()
 956 {
 957    return blockCount;
 958 }
 959
 960 uint16               rNRGSession::getBlockSize()
 961 {
 962    return blockSize;
 963 }
 964
 965 const char          *rNRGSession::static_getName()
 966 {
 967    return "Nero Burning ROM Image";
 968 }
 969
 970 bool                 rNRGSession::static_isAudio()
 971 {
 972    return false;
 973 }
 974
 975 bool                 rNRGSession::static_isData()
 976 {
 977    return false;
 978 }
 979
 980 bool                 rNRGSession::static_isSession()
 981 {
 982    return true;
 983 }
 984
 985 bool                 rNRGSession::checkFile(const char* file, EDtError &rc)
 986 {
 987    BPTR   fh;
 988    uint32 data;
 989    uint32 size;
 990    int    res = true;
 991
 992    rc = DT_UnableToOpenFile;
 993
 994    fh = DOS->Open(const_cast<char*>(file), MODE_OLDFILE);
 995    if (0 == fh)
 996       return false;
 997
 998    rc = DT_OK;
 999
1000    DOS->Seek(fh, -4, OFFSET_END);
1001    size = DOS->Seek(fh, 0, OFFSET_CURRENT) + 4;    // fancy, innit
1002
1003    DOS->Read(fh, &data, 4);
1004    data = L2BE(data);
1005    if ((size - data) > 4096)
1006       return false;
1007
1008    DOS->Seek(fh, data, OFFSET_BEGINNING);
1009
1010    do
1011    {
1012       DOS->Read(fh, &data, 4);
1013       data = L2BE(data);
1014       if ((data == MAKE_ID('C','D','T','X')) ||
1015           (data == MAKE_ID('C','U','E','X')) ||
1016           (data == MAKE_ID('C','U','E','S')) ||
1017           (data == MAKE_ID('D','A','O','X')) ||
1018           (data == MAKE_ID('D','A','O','I')) ||
1019           (data == MAKE_ID('E','T','N','F')) ||
1020           (data == MAKE_ID('E','T','N','2')) ||
1021           (data == MAKE_ID('N','E','R','O')) ||
1022           (data == MAKE_ID('N','E','R','5')) ||
1023           (data == MAKE_ID('S','I','N','F')) ||
1024           (data == MAKE_ID('M','T','Y','P')))
1025       {
1026          DOS->Read(fh, &data, 4);
1027          data = L2BE(data);
1028          DOS->Seek(fh, data, OFFSET_CURRENT);
1029       }
1030       else if (data == MAKE_ID('E','N','D','!'))
1031       {
1032          break;
1033       }
1034       else
1035       {
1036          res = false;
1037          break;
1038       }
1039    }
1040    while (true);
1041
1042    DOS->Close(fh);
1043    return res;
1044 }
1045
1046 DbgHandler*          rNRGSession::getDebug()
1047 {
1048    return dbg;
1049 }
1050
1051 void                 rNRGSession::setDebug(DbgHandler* nd)
1052 {
1053    dbg = nd;
1054 }
1055