File indexing completed on 2024-04-14 04:49:21

 /*
  *  KCompactDisc - A CD drive interface for the KDE Project.
  *
  *  Copyright (C) 2007 Alexander Kern <alex.kern@gmx.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2, or (at your option)
  *  any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "wmlib_interface.h"
 
 #include <QtGlobal>
 
 #include <KLocalizedString>
 
 extern "C"
 {
     // We don't have libWorkMan installed already, so get everything
     // from within our own directory
     #include "wmlib/include/wm_cdrom.h"
     #include "wmlib/include/wm_cdtext.h"
     #include "wmlib/include/wm_helpers.h"
 }
 
 #define TRACK_VALID(track) ((track) && (track <= m_tracks))
 
 KWMLibCompactDiscPrivate::KWMLibCompactDiscPrivate(KCompactDisc *p,
     const QString &dev, const QString &audioSystem, const QString &audioDevice) :
     KCompactDiscPrivate(p, dev),
     m_handle(nullptr),
     m_audioSystem(audioSystem),
     m_audioDevice(audioDevice)
 {
     m_interface = m_audioSystem;
 }
 
 KWMLibCompactDiscPrivate::~KWMLibCompactDiscPrivate()
 {
     if (m_handle) {
         wm_cd_destroy(m_handle);
     }
 }
 
 bool KWMLibCompactDiscPrivate::createInterface()
 {
     const QString devicePath = KCompactDisc::cdromDeviceUrl(m_deviceName).path();
 
     // Debug.
     if (qEnvironmentVariableIsSet("KCOMPACTDISC_WMLIB_DEBUG")) {
         wm_cd_set_verbosity(WM_MSG_LEVEL_DEBUG | WM_MSG_CLASS_ALL);
     }
 
     int status = wm_cd_init(
         devicePath.toLatin1().data(),
         m_audioSystem.toLatin1().data(),
         m_audioDevice.toLatin1().data(),
         nullptr,
         &m_handle);
 
     if(!WM_CDS_ERROR(status)) {
         m_deviceVendor = QLatin1String(wm_drive_vendor(m_handle));
         m_deviceModel = QLatin1String(wm_drive_model(m_handle));
         m_deviceRevision = QLatin1String(wm_drive_revision(m_handle));
 
         Q_Q(KCompactDisc);
         Q_EMIT q->discChanged(0);
 
         if (m_infoMode == KCompactDisc::Asynchronous) {
             timerExpired();
         } else {
             QTimer::singleShot(1000, this, SLOT(timerExpired()));
         }
 
         return true;
     }
     m_handle = nullptr;
     return false;
 }
 
 unsigned KWMLibCompactDiscPrivate::trackLength(unsigned track)
 {
     return (unsigned)wm_cd_gettracklen(m_handle, track);
 }
 
 bool KWMLibCompactDiscPrivate::isTrackAudio(unsigned track)
 {
     return !wm_cd_gettrackdata(m_handle, track);
 }
 
 void KWMLibCompactDiscPrivate::playTrackPosition(unsigned track, unsigned position)
 {
     unsigned firstTrack, lastTrack;
 
     firstTrack = TRACK_VALID(track) ? track : 1;
     lastTrack = firstTrack + 1;
     lastTrack = TRACK_VALID(lastTrack) ? lastTrack : WM_ENDTRACK;
 
     qDebug() << "play track " << firstTrack << " position "
                  << position;
 
     wm_cd_play(m_handle, firstTrack, position, lastTrack);
 }
 
 void KWMLibCompactDiscPrivate::pause()
 {
     wm_cd_pause(m_handle);
 }
 
 void KWMLibCompactDiscPrivate::stop()
 {
     wm_cd_stop(m_handle);
 }
 
 void KWMLibCompactDiscPrivate::eject()
 {
     wm_cd_eject(m_handle);
 }
 
 void KWMLibCompactDiscPrivate::closetray()
 {
     wm_cd_closetray(m_handle);
 }
 
 /* WM_VOLUME_MUTE ... WM_VOLUME_MAXIMAL */
 /* WM_BALANCE_ALL_LEFTS .WM_BALANCE_SYMMETRED. WM_BALANCE_ALL_RIGHTS */
 #define RANGE2PERCENT(x, min, max) (((x) - (min)) * 100)/ ((max) - (min))
 #define PERCENT2RANGE(x, min, max) ((((x) * ((max) - (min))) / 100 ) + (min))
 void KWMLibCompactDiscPrivate::setVolume(unsigned volume)
 {
     int vol, bal;
     vol = PERCENT2RANGE(volume, WM_VOLUME_MUTE, WM_VOLUME_MAXIMAL);
     bal = wm_cd_getbalance(m_handle);
     wm_cd_volume(m_handle, vol, bal);
 }
 
 void KWMLibCompactDiscPrivate::setBalance(unsigned balance)
 {
     int vol, bal;
     vol = wm_cd_getvolume(m_handle);
     bal = PERCENT2RANGE(balance, WM_BALANCE_ALL_LEFTS, WM_BALANCE_ALL_RIGHTS);
     wm_cd_volume(m_handle, vol, bal);
 }
 
 unsigned KWMLibCompactDiscPrivate::volume()
 {
     int vol = wm_cd_getvolume(m_handle);
     unsigned volume = RANGE2PERCENT(vol, WM_VOLUME_MUTE, WM_VOLUME_MAXIMAL);
     return volume;
 }
 
 unsigned KWMLibCompactDiscPrivate::balance()
 {
     int bal = wm_cd_getbalance(m_handle);
     unsigned balance = RANGE2PERCENT(bal, WM_BALANCE_ALL_LEFTS, WM_BALANCE_ALL_RIGHTS);
 
     return balance;
 }
 
 void KWMLibCompactDiscPrivate::queryMetadata()
 {
     cdtext();
     //cddb();
 }
 
 KCompactDisc::DiscStatus KWMLibCompactDiscPrivate::discStatusTranslate(int status)
 {
     switch (status) {
     case WM_CDM_TRACK_DONE:
     case WM_CDM_PLAYING:
     case WM_CDM_FORWARD:
         return KCompactDisc::Playing;
     case WM_CDM_PAUSED:
         return KCompactDisc::Paused;
     case WM_CDM_STOPPED:
         return KCompactDisc::Stopped;
     case WM_CDM_EJECTED:
         return KCompactDisc::Ejected;
     case WM_CDM_NO_DISC:
     case WM_CDM_UNKNOWN:
         return KCompactDisc::NoDisc;
     case WM_CDM_CDDAERROR:
     case WM_CDM_LOADING:
     case WM_CDM_BUFFERING:
         return KCompactDisc::NotReady;
     default:
         return KCompactDisc::Error;
     }
 }
 
 void KWMLibCompactDiscPrivate::timerExpired()
 {
     KCompactDisc::DiscStatus status;
     unsigned track, i;
     Q_Q(KCompactDisc);
 
     status = discStatusTranslate(wm_cd_status(m_handle));
 
     if(m_status != status) {
         if(skipStatusChange(status))
             goto timerExpiredExit;
 
         m_status = status;
 
         switch(m_status) {
         case KCompactDisc::Ejected:
         case KCompactDisc::NoDisc:
             clearDiscInfo();
             break;
         default:
             if(m_tracks == 0) {
                 m_tracks = wm_cd_getcountoftracks(m_handle);
                 if(m_tracks > 0) {
                     qDebug() << "New disc with " << m_tracks << " tracks";
                     m_discId = wm_cddb_discid(m_handle);
 
                     for(i = 1; i <= m_tracks; ++i) {
                         m_trackStartFrames.append(wm_cd_gettrackstart(m_handle, i));
                     }
                     m_trackStartFrames.append(wm_cd_gettrackstart(m_handle, i));
 
                     m_discLength = FRAMES2SEC(m_trackStartFrames[m_tracks] -
                         m_trackStartFrames[0]);
 
                     make_playlist();
 
                     m_trackArtists.append(i18n("Unknown Artist"));
                     m_trackTitles.append(i18n("Unknown Title"));
                     for(i = 1; i <= m_tracks; ++i) {
                         m_trackArtists.append(i18n("Unknown Artist"));
                         m_trackTitles.append(ki18n("Track %1").subs(i, 2).toString());
                     }
 
 qDebug() << "m_tracks " << m_tracks;
 qDebug() << "m_trackStartFrames " << m_trackStartFrames;
 qDebug() << "m_trackArtists " << m_trackArtists;
 qDebug() << "m_trackTitles " << m_trackTitles;
 
                     Q_EMIT q->discChanged(m_tracks);
 
                     if(m_autoMetadata)
                         queryMetadata();
                 }
             }
             break;
         }
     }
 
     switch(m_status) {
     case KCompactDisc::Playing:
         m_trackPosition = wm_get_cur_pos_rel(m_handle);
         m_discPosition = wm_get_cur_pos_abs(m_handle) - FRAMES2SEC(m_trackStartFrames[0]);
         // Update the current playing position.
         if(m_seek) {
             qDebug() << "seek: " << m_seek << " trackPosition " << m_trackPosition;
             if(abs((long)(m_trackExpectedPosition - m_trackPosition)) > m_seek)
                 m_seek = 0;
             else
                 m_seek = abs((long)(m_trackExpectedPosition - m_trackPosition));
         }
 
         if(!m_seek) {
             Q_EMIT q->playoutPositionChanged(m_trackPosition);
             //Q_EMIT q->playoutDiscPositionChanged(m_discPosition);
         }
 
         // Per-event processing.
         track = wm_cd_getcurtrack(m_handle);
 
         if(m_track != track) {
             m_track = track;
             Q_EMIT q->playoutTrackChanged(m_track);
         }
         break;
 
     case KCompactDisc::Stopped:
         m_seek = 0;
         m_track = 0;
         break;
 
     default:
         break;
     }
 
 timerExpiredExit:
     // Now that we have incurred any delays caused by the signals, we'll start the timer.
     QTimer::singleShot(1000, this, SLOT(timerExpired()));
 }
 
 void KWMLibCompactDiscPrivate::cdtext()
 {
     struct cdtext_info *info;
     unsigned i;
     Q_Q(KCompactDisc);
 
     info = wm_cd_get_cdtext(m_handle);
 
     if(!info || !info->valid || (unsigned)info->count_of_entries != (m_tracks + 1)) {
         qDebug() << "no or invalid CDTEXT";
         return;
     }
 
     m_trackArtists[0] = QLatin1String( reinterpret_cast<char*>(info->blocks[0]->performer[0]) );
     m_trackTitles[0] = QLatin1String( reinterpret_cast<char*>(info->blocks[0]->name[0]) );
 
     for(i = 1; i <= m_tracks; ++i) {
             m_trackArtists[i] = QLatin1String( reinterpret_cast<char*>(info->blocks[0]->performer[i]) );
             m_trackTitles[i] =QLatin1String( reinterpret_cast<char*>(info->blocks[0]->name[i]) );
     }
 
     qDebug() << "CDTEXT";
     qDebug() << "m_trackArtists " << m_trackArtists;
     qDebug() << "m_trackTitles " << m_trackTitles;
 
     Q_EMIT q->discInformation(KCompactDisc::Cdtext);
 }
 
 #include "moc_wmlib_interface.cpp"