FryingPan/Optical/OptItem.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 "OptItem.h"
  21
  22 using namespace GenNS;
  23
  24 OptItem::OptItem(IOptItem *parent)
  25 {
  26    di_parent         = parent;
  27    di_itemtype       = Item_Disc;
  28    di_number         = 0;
  29    di_flags          = 0;
  30    di_datatype       = Data_Unknown;
  31
  32    di_pregap         = 0;
  33    di_postgap        = 0;
  34
  35    di_start          = 0;
  36    di_datasize       = 0;
  37    di_actual         = 0;
  38    di_sectorsize     = 0;
  39    di_opencnt        = 0;
  40
  41    di_prot           = false;
  42    di_preemph        = false;
  43    di_incremental    = false;
  44    di_blank          = false;
  45    di_cdtext         = false;
  46    di_packetlength   = 16;
  47
  48    di_discid         = 0;
  49
  50    claim();
  51 }
  52
  53 OptItem::~OptItem()
  54 {
  55    di_children.ForEach(&sFreeChild);
  56 }
  57
  58 bool           OptItem::sFreeChild(IOptItem* const& child)
  59 {
  60    child->dispose();
  61    return true;
  62 }
  63
  64 IOptItem      *OptItem::addChild(IOptItem* child)
  65 {
  66    di_children << child;
  67    return child;
  68 }
  69
  70 void           OptItem::printReport(DbgHandler *__dbg) const
  71 {
  72    if (0 == __dbg)
  73       return;
  74
  75    _D(Lvl_Info, "Item type:     %s",  (int)(getItemType() == Item_Disc      ? "Disc" :
  76                                               getItemType() == Item_Session   ? "Session" :
  77                                               getItemType() == Item_Track     ? "Track" : "Index"));
  78    _D(Lvl_Info, "Item number:   %ld", getItemNumber());
  79    _D(Lvl_Info, "Flags:         %ld", getFlags());
  80    _D(Lvl_Info, "Type:          %ld", getDataType());
  81    _D(Lvl_Info, "Start:         %ld", getStartAddress());
  82    _D(Lvl_Info, "End:           %ld", getEndAddress());
  83 //   _d(Lvl_Info, "Actual:        %ld", GetActualAddress());
  84    _D(Lvl_Info, "Total:         %ld", getBlockCount());
  85    _D(Lvl_Info, "SectorSize:    %ld", getSectorSize());
  86    _D(Lvl_Info, "Protected?:    %ld", isProtected());
  87    _D(Lvl_Info, "Preemph.?:     %ld", isPreemphasized());
  88    _D(Lvl_Info, "Incremental?:  %ld", isIncremental());
  89    _D(Lvl_Info, "Blank?:        %ld", isBlank());
  90    _D(Lvl_Info, "Packet size:   %ld", getPacketSize());
  91    _D(Lvl_Info, "-----------------------");
  92 }
  93
  94    /*
  95     * inherited methods go here
  96     */
  97
  98 void           OptItem::claim() const
  99 {
 100    const_cast<OptItem*>(this)->di_sync.Acquire();
 101    ++const_cast<OptItem*>(this)->di_opencnt;
 102    const_cast<OptItem*>(this)->di_sync.Release();
 103 }
 104
 105 void           OptItem::dispose() const
 106 {
 107    const_cast<OptItem*>(this)->di_sync.Acquire();
 108    ASSERT(di_opencnt != 0);
 109    --const_cast<OptItem*>(this)->di_opencnt;
 110    if (di_opencnt == 0)
 111       delete const_cast<OptItem*>(this);
 112    else
 113       const_cast<OptItem*>(this)->di_sync.Release();
 114 }
 115
 116 EItemType      OptItem::getItemType() const
 117 {
 118    return di_itemtype;
 119 }
 120
 121 void           OptItem::setItemType(EItemType lNewType)
 122 {
 123    di_itemtype = lNewType;
 124 }
 125
 126 uint16         OptItem::getItemNumber() const
 127 {
 128    return di_number;
 129 }
 130
 131 void           OptItem::setItemNumber(uint16 number)
 132 {
 133    di_number = number;
 134 }
 135
 136 EDataType      OptItem::getDataType() const
 137 {
 138    return di_datatype;
 139 }
 140
 141 void           OptItem::setDataType(EDataType lNewType)
 142 {
 143    di_datatype = lNewType;
 144 }
 145
 146 uint16         OptItem::getPreGapSize() const
 147 {
 148    return di_pregap;
 149 }
 150
 151 void           OptItem::setPreGapSize(uint16 lNewSize)
 152 {
 153    di_pregap = lNewSize;
 154 }
 155
 156 uint16         OptItem::getPostGapSize() const
 157 {
 158    return di_postgap;
 159 }
 160
 161 void           OptItem::setPostGapSize(uint16 lNewSize)
 162 {
 163    di_postgap = lNewSize;
 164 }
 165
 166 int32          OptItem::getStartAddress() const
 167 {
 168    if (getFlags() & DIF_RelativeSize)
 169    {
 170       return getParent()->getDataStartAddress() + di_start;
 171    }
 172    return di_start;
 173 }
 174
 175 void           OptItem::setStartAddress(int32 lNewAddress)
 176 {
 177    di_start = lNewAddress;
 178 }
 179
 180 int32          OptItem::getEndAddress() const
 181 {
 182    return getStartAddress() + getDataBlockCount() + getPreGapSize() + getPostGapSize() - 1;
 183 }
 184
 185 void           OptItem::setEndAddress(int32 lNewAddress)
 186 {
 187    di_datasize = lNewAddress + 1 - getPreGapSize() - getPostGapSize() - getStartAddress();
 188 }
 189
 190 int32          OptItem::getBlockCount() const
 191 {
 192    return (getEndAddress() + 1) - getStartAddress();
 193 }
 194
 195 int32          OptItem::getDataBlockCount() const
 196 {
 197    if (getFlags() & DIF_RelativeSize)
 198    {
 199       if (di_datasize == -1)
 200          return getParent()->getDataBlockCount();
 201    }
 202    return di_datasize;
 203 }
 204
 205 void           OptItem::setDataBlockCount(int32 size)
 206 {
 207    di_datasize = size;
 208 }
 209
 210 int32          OptItem::getDataStartAddress() const
 211 {
 212    return getStartAddress() + getPreGapSize();
 213 }
 214
 215 int32          OptItem::getDataEndAddress() const
 216 {
 217    return getStartAddress() + getPreGapSize() + getDataBlockCount() - 1;
 218 }
 219
 220 bool           OptItem::isProtected() const
 221 {
 222    return di_prot;
 223 }
 224
 225 void           OptItem::setProtected(bool bProtected)
 226 {
 227    di_prot = bProtected;
 228 }
 229
 230 bool           OptItem::isPreemphasized() const
 231 {
 232    return di_preemph;
 233 }
 234
 235 void           OptItem::setPreemphasized(bool bPreemph)
 236 {
 237    di_preemph = bPreemph;
 238 }
 239
 240 bool           OptItem::isIncremental() const
 241 {
 242    return di_incremental;
 243 }
 244
 245 void           OptItem::setIncremental(bool bState)
 246 {
 247    di_incremental = bState;
 248 }
 249
 250 bool           OptItem::hasCDText() const
 251 {
 252    return di_cdtext;
 253 }
 254
 255 void           OptItem::setCDText(bool bCDText)
 256 {
 257    di_cdtext = bCDText;
 258 }
 259
 260 const char*    OptItem::getCDTTitle() const
 261 {
 262    return di_title.Data();
 263 }
 264
 265 void           OptItem::setCDTTitle(const char* sNewTitle)
 266 {
 267    di_title = sNewTitle;
 268    if (di_title.Length() > 0)
 269       setCDText(true);
 270 }
 271
 272 const char*    OptItem::getCDTArtist() const
 273 {
 274    return di_artist.Data();
 275 }
 276
 277 void           OptItem::setCDTArtist(const char* sNewArtist)
 278 {
 279    di_artist = sNewArtist;
 280    if (di_artist.Length() > 0)
 281       setCDText(true);
 282 }
 283
 284 const char*    OptItem::getCDTMessage() const
 285 {
 286    return di_message.Data();
 287 }
 288
 289 void           OptItem::setCDTMessage(const char* sNewMessage)
 290 {
 291    di_message = sNewMessage;
 292    if (di_message.Length() > 0)
 293       setCDText(true);
 294 }
 295
 296 const char*    OptItem::getCDTLyrics() const
 297 {
 298    return di_lyrics.Data();
 299 }
 300
 301 void           OptItem::setCDTLyrics(const char* sNewLyrics)
 302 {
 303    di_lyrics = sNewLyrics;
 304    if (di_lyrics.Length() > 0)
 305       setCDText(true);
 306 }
 307
 308 const char*    OptItem::getCDTComposer() const
 309 {
 310    return di_composer.Data();
 311 }
 312
 313 void           OptItem::setCDTComposer(const char* sNewComposer)
 314 {
 315    di_composer = sNewComposer;
 316    if (di_composer.Length() > 0)
 317       setCDText(true);
 318 }
 319
 320 const char*    OptItem::getCDTDirector() const
 321 {
 322    return di_director.Data();
 323 }
 324
 325 void           OptItem::setCDTDirector(const char* sNewDirector)
 326 {
 327    di_director = sNewDirector;
 328    if (di_director.Length() > 0)
 329       setCDText(true);
 330 }
 331
 332 const IOptItem*OptItem::getParent() const
 333 {
 334    return di_parent;
 335 }
 336
 337 const IOptItem*OptItem::getChild(int32 num) const
 338 {
 339    return di_children[num];
 340 }
 341
 342 int32          OptItem::getChildCount() const
 343 {
 344    return di_children.Count();
 345 }
 346
 347 bool           OptItem::isBlank() const
 348 {
 349    return di_blank;
 350 }
 351
 352 void           OptItem::setBlank(bool blank)
 353 {
 354    di_blank = blank;
 355 }
 356
 357 uint16         OptItem::getSectorSize() const
 358 {
 359    return di_sectorsize;
 360 }
 361
 362 void           OptItem::setSectorSize(uint16 size)
 363 {
 364    di_sectorsize = size;
 365 }
 366
 367 uint32         OptItem::getDiscID() const
 368 {
 369    return di_discid;
 370 }
 371
 372 void           OptItem::setDiscID(uint32 id)
 373 {
 374    di_discid = id;
 375 }
 376
 377 uint16         OptItem::getPacketSize() const
 378 {
 379    return di_packetlength;
 380 }
 381
 382 void           OptItem::setPacketSize(uint16 lNewSize)
 383 {
 384    di_packetlength = lNewSize;
 385 }
 386
 387 uint16          OptItem::getFlags() const
 388 {
 389    return di_flags;
 390 }
 391
 392 void           OptItem::setFlags(uint16 lNewFlags)
 393 {
 394    di_flags = lNewFlags;
 395 }
 396
 397 void           OptItem::setComplete(bool cmpl)
 398 {
 399    di_complete = cmpl;
 400 }
 401
 402 bool           OptItem::isComplete() const
 403 {
 404    return di_complete;
 405 }
 406