File indexing completed on 2025-03-16 04:29:58

 /*
     SPDX-FileCopyrightText: 1998-2009 Sebastian Trueg <trueg@k3b.org>
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "k3btrack.h"
 
 #include <QSharedData>
 
 class K3b::Device::Track::Private : public QSharedData
 {
 public:
     Private( const K3b::Msf& fs = K3b::Msf(),
              const K3b::Msf& ls = K3b::Msf(),
              TrackType t = TYPE_UNKNOWN,
              DataMode m = UNKNOWN )
         : firstSector( fs ),
           lastSector( ls ),
           type( t ),
           mode( m ),
           copyPermitted(true),
           preEmphasis(false),
           session(0) {
     }
 
     K3b::Msf firstSector;
     K3b::Msf lastSector;
     K3b::Msf index0;
 
     K3b::Msf nextWritableAddress;
     K3b::Msf freeBlocks;
 
     TrackType type;
     DataMode mode;
     bool copyPermitted;
     bool preEmphasis;
 
     int session;
 
     QList<K3b::Msf> indices;
 
     QByteArray isrc;
 };
 
 
 K3b::Device::Track::Track()
     : d( new Private() )
 {
 }
 
 
 K3b::Device::Track::Track( const Track& track )
 {
     d = track.d;
 }
 
 
 K3b::Device::Track::Track( const K3b::Msf& firstSector,
                            const K3b::Msf& lastSector,
                            TrackType type,
                            DataMode mode )
     : d( new Private( firstSector,
                       lastSector,
                       type,
                       mode ) )
 {
 }
 
 
 K3b::Device::Track::~Track()
 {
 }
 
 
 K3b::Device::Track& K3b::Device::Track::operator=( const Track& track )
 {
     d = track.d;
     return *this;
 }
 
 
 K3b::Msf K3b::Device::Track::length() const
 {
     // +1 since the last sector is included
     return d->lastSector - d->firstSector + 1;
 }
 
 
 K3b::Device::Track::TrackType K3b::Device::Track::type() const
 {
     return d->type;
 }
 
 
 void K3b::Device::Track::setType( TrackType t )
 {
     d->type = t;
 }
 
 
 K3b::Device::Track::DataMode K3b::Device::Track::mode() const
 {
     return d->mode;
 }
 
 
 void K3b::Device::Track::setMode( DataMode m )
 {
     d->mode = m;
 }
 
 
 bool K3b::Device::Track::copyPermitted() const
 {
     return d->copyPermitted;
 }
 
 
 void K3b::Device::Track::setCopyPermitted( bool b )
 {
     d->copyPermitted = b;
 }
 
 
 bool K3b::Device::Track::preEmphasis() const
 {
     return d->preEmphasis;
 }
 
 
 void K3b::Device::Track::setPreEmphasis( bool b )
 {
     d->preEmphasis = b;
 }
 
 
 bool K3b::Device::Track::recordedIncremental() const
 {
     return d->preEmphasis;
 }
 
 
 bool K3b::Device::Track::recordedUninterrupted() const
 {
     return !recordedIncremental();
 }
 
 
 QByteArray K3b::Device::Track::isrc() const
 {
     return d->isrc;
 }
 
 
 void K3b::Device::Track::setIsrc( const QByteArray& s )
 {
     d->isrc = s;
 }
 
 
 K3b::Msf K3b::Device::Track::firstSector() const
 {
     return d->firstSector;
 }
 
 
 K3b::Msf K3b::Device::Track::lastSector() const
 {
     return d->lastSector;
 }
 
 
 void K3b::Device::Track::setFirstSector( const K3b::Msf& msf )
 {
     d->firstSector = msf;
 }
 
 
 void K3b::Device::Track::setLastSector( const K3b::Msf& msf )
 {
     d->lastSector = msf;
 }
 
 
 K3b::Msf K3b::Device::Track::nextWritableAddress() const
 {
     return d->nextWritableAddress;
 }
 
 
 void K3b::Device::Track::setNextWritableAddress( const K3b::Msf& m )
 {
     d->nextWritableAddress = m;
 }
 
 
 void K3b::Device::Track::setFreeBlocks( const K3b::Msf& m )
 {
     d->freeBlocks = m;
 }
 
 
 K3b::Msf K3b::Device::Track::freeBlocks() const
 {
     return d->freeBlocks;
 }
 
 
 K3b::Msf K3b::Device::Track::realAudioLength() const
 {
     if( index0() > 0 )
         return index0();
     else
         return length();
 }
 
 
 int K3b::Device::Track::session() const
 {
     return d->session;
 }
 
 
 void K3b::Device::Track::setSession( int s )
 {
     d->session = s;
 }
 
 
 K3b::Msf K3b::Device::Track::index0() const
 {
     return d->index0;
 }
 
 
 QList<K3b::Msf> K3b::Device::Track::indices() const
 {
     return d->indices;
 }
 
 
 void K3b::Device::Track::setIndices( const QList<K3b::Msf>& il )
 {
     d->indices = il;
 }
 
 
 void K3b::Device::Track::setIndex0( const K3b::Msf& msf )
 {
     if( msf <= d->lastSector-d->firstSector )
         d->index0 = msf;
 }
 
 
 int K3b::Device::Track::indexCount() const
 {
     return d->indices.count()-1;
 }
 
 
 bool K3b::Device::Track::operator==( const Track& other ) const
 {
     return( d->firstSector == other.d->firstSector &&
             d->lastSector == other.d->lastSector &&
             d->index0 == other.d->index0 &&
             d->nextWritableAddress == other.d->nextWritableAddress &&
             d->freeBlocks == other.d->freeBlocks &&
             d->type == other.d->type &&
             d->mode == other.d->mode &&
             d->copyPermitted == other.d->copyPermitted &&
             d->preEmphasis == other.d->preEmphasis &&
             d->session == other.d->session &&
             d->indices == other.d->indices &&
             d->isrc == other.d->isrc );
 }
 
 
 bool K3b::Device::Track::operator!=( const Track& other ) const
 {
     return !operator==( other );
 }
 
 
 QDebug operator<<( QDebug s, const K3b::Device::Track& track )
 {
     s.nospace() << ( track.type() == K3b::Device::Track::TYPE_AUDIO ? " AUDIO" : " DATA" )
                 << " " << track.firstSector().lba() << " - " << track.lastSector().lba()
                 << " (" << track.length().lba() << ")";
     return s;
 }
 
 
 uint qHash( const K3b::Device::Track& key )
 {
     // this is a dummy implementation to make it compile on windows
     return qHash((long)&key);
 }