Ticket #9362: 40-mythmusic-cdio-cddecoder.diff

mythplugins/mythmusic/mythmusic/decoder.cpp

@@ -181 +181 @@
     {
         factories = new QList<DecoderFactory*>;
 
-#ifndef USING_MINGW
         Decoder::registerFactory(new CdDecoderFactory);
-#endif // USING_MINGW
         Decoder::registerFactory(new avfDecoderFactory);
     }
 }

mythplugins/mythmusic/mythmusic/cddecoder.h

@@ -9 +9 @@
 #include <vector>
 #endif
 
-#if defined(__linux__) || defined(__FreeBSD__)
+#ifdef HAVE_CDAUDIO
 #include <cdaudio.h>
+#endif
+
+#ifdef HAVE_CDIO
+# include <cdio/cdda.h>
+# include <cdio/paranoia.h>
+#elif defined HAVE_PARANOIA
 extern "C" {
-#include <cdda_interface.h>
-#include <cdda_paranoia.h>
+# include <cdda_interface.h>
+# include <cdda_paranoia.h>
 }
 #endif
 
@@ -23 +29 @@
 {
   public:
     CdDecoder(const QString &file, DecoderFactory *, QIODevice *, AudioOutput *);
-    virtual ~CdDecoder(void);
+    virtual ~CdDecoder();
 
-    bool initialize();
-    double lengthInSeconds();
-    void seek(double);
-    void stop();
+    // Decoder implementation
+    virtual bool initialize();
+    virtual void seek(double);
+    virtual void stop();
 
-    int getNumTracks(void);
-    int getNumCDAudioTracks(void);
+    // Decoder overrides
+    virtual Metadata *getMetadata(void);
+    virtual void commitMetadata(Metadata *mdata);
 
     // The following need to allocate a new Metadata object each time,
     // because their callers (e.g. databasebox.cpp) free the returned value
     Metadata *getMetadata(int track);
-    Metadata *getMetadata(void);
-    Metadata *getLastMetadata(void);
+    Metadata *getLastMetadata();
 
-    void commitMetadata(Metadata *mdata);
-    void      setDevice(const QString &dev)  { devicename = dev; }
+#if CONFIG_DARWIN
+    double lengthInSeconds();
+#endif
+    int getNumTracks();
+    int getNumCDAudioTracks();
+
+    void      setDevice(const QString &dev);
+#ifndef HAVE_CDIO
+    void      setDevice(const QString &dev)  { this->devicename = dev; }
+#endif
     void      setCDSpeed(int speed);
 
   private:
     void run();
 
-    void writeBlock(void);
+    void writeBlock();
     void deinit();
 
     bool inited, user_stop;
@@ -64 +78 @@
     vector<int>        m_tracks;        ///< Start block offset of each track
     vector<Metadata*>  m_mData;         ///< After lookup, details of each trk
 #endif
+#ifdef HAVE_CDIO
+    static QMutex& getCdioMutex();
+#endif
 
-    int stat;
+    DecoderEvent::Type stat;
     char *output_buf;
-    ulong output_at;
+    std::size_t output_at;
 
-    unsigned int bks, bksFrames, decodeBytes;
+    std::size_t bks, bksFrames, decodeBytes;
     bool finish;
     long freq, bitrate;
     int chan;
@@ -78 +95 @@
     int settracknum;
     int tracknum;
 
-#if defined(__linux__) || defined(__FreeBSD__)
+#ifdef HAVE_CDIO
+    CdIo_t *cdio;
+    cdrom_drive_t *device;
+    cdrom_paranoia_t *paranoia;
+    lsn_t start, end, curpos;
+#elif defined HAVE_PARANOIA
     cdrom_drive *device;
     cdrom_paranoia *paranoia;
+    long int start, end, curpos;
 #endif
-
-    long int start, end, curpos;
 };
 
 #endif

mythplugins/mythmusic/mythmusic/cddecoder-cdio.cpp

@@ +1 @@
+#define DO_NOT_WANT_PARANOIA_COMPATIBILITY
+#include "cddecoder.h"
+
+// C
+#include <cstdlib>
+#include <cstring>
+
+#include <unistd.h>
+
+// Qt
+#include <QIODevice>
+#include <QFile>
+#include <QObject>
+#include <QString>
+
+// libcdio
+#include <cdio/cdda.h>
+
+// MythTV
+#include <audiooutput.h>
+#include <mythcontext.h>
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+}
+
+// MythMusic
+#include "constants.h"
+#include "metadata.h"
+#include "cddb.h"
+
+#define CDEXT ".cda"
+const unsigned kSamplesPerSec = 44100;
+
+
+// Open a cdio device
+static CdIo_t * openCdio(const QString& name)
+{
+    CdIo_t *cdio = cdio_open(name.toAscii(), DRIVER_DEVICE);
+    if (!cdio)
+    {
+        VERBOSE(VB_MEDIA, QString("CdDecoder: cdio_open(%1) failed").
+            arg(name));
+    }
+    return cdio;
+}
+
+// Stack-based cdio device open
+class StCdioDevice
+{
+    CdIo_t* m_cdio;
+
+    void* operator new(std::size_t); // Stack only
+    // No copying
+    StCdioDevice(const StCdioDevice&);
+    StCdioDevice& operator =(const StCdioDevice&);
+
+public:
+    StCdioDevice(const QString& dev) : m_cdio(openCdio(dev)) { }
+    ~StCdioDevice() { if (m_cdio) cdio_destroy(m_cdio); }
+
+    operator CdIo_t*() const { return m_cdio; }
+};
+
+
+CdDecoder::CdDecoder(const QString &file, DecoderFactory *d, QIODevice *i,
+                     AudioOutput *o) :
+    Decoder(d, i, o),
+    inited(false),   user_stop(false),
+    devicename(""),
+    stat(DecoderEvent::Error),
+    output_buf(NULL),
+    output_at(0),    bks(0),
+    bksFrames(0),    decodeBytes(0),
+    finish(false),
+    freq(0),         bitrate(0),
+    chan(0),
+    seekTime(-1.),
+    settracknum(-1), tracknum(0),
+    cdio(0),        device(0), paranoia( 0),
+    start(CDIO_INVALID_LSN),
+    end(CDIO_INVALID_LSN),
+    curpos(CDIO_INVALID_LSN)
+{
+    setFilename(file);
+}
+
+// virtual
+CdDecoder::~CdDecoder()
+{
+    if (this->inited)
+        deinit();
+}
+
+void CdDecoder::setDevice(const QString &dev)
+{
+    this->devicename = dev;
+#ifdef WIN32
+    // libcdio needs the drive letter with no path
+    if (this->devicename.endsWith('\\'))
+        this->devicename.chop(1);
+#endif
+}
+
+// pure virtual
+void CdDecoder::stop()
+{
+    this->user_stop = true;
+}
+
+void CdDecoder::writeBlock()
+{
+    while (this->seekTime <= +0.)
+    {
+        if(output()->AddFrames(this->output_buf, this->bksFrames, -1))
+        {
+            if (this->output_at >= this->bks)
+            {
+                this->output_at -= this->bks;
+                std::memmove(this->output_buf, this->output_buf + this->bks,
+                    this->output_at);
+            }
+            break;
+        }
+        else
+            ::usleep(output()->GetAudioBufferedTime()<<9);
+    }
+}
+
+//static
+QMutex& CdDecoder::getCdioMutex()
+{
+    static QMutex mtx(QMutex::Recursive);
+    return mtx;
+}
+
+// pure virtual
+bool CdDecoder::initialize()
+{
+    if (this->inited)
+        return true;
+
+    this->inited = this->user_stop = this->finish = false;
+    this->freq = this->bitrate = 0L;
+    this->stat = DecoderEvent::Error;
+    this->chan = 0;
+    this->seekTime = -1.;
+
+    if (output())
+        output()->PauseUntilBuffered();
+
+    QFile* file = dynamic_cast< QFile* >(input()); // From QIODevice*
+    if (file)
+    {
+        setFilename(file->fileName());
+        this->tracknum = getFilename().section('.', 0, 0).toUInt();
+    }
+
+    QMutexLocker lock(&getCdioMutex());
+
+    this->cdio = openCdio(this->devicename);
+    if (!this->cdio)
+        return false;
+
+    this->start = cdio_get_track_lsn(this->cdio, this->tracknum);
+    this->end = cdio_get_track_last_lsn(this->cdio, this->tracknum);
+    if (CDIO_INVALID_LSN  == this->start ||
+        CDIO_INVALID_LSN  == this->end)
+    {
+        VERBOSE(VB_MEDIA, "CdDecoder: No tracks on " + this->devicename);
+        cdio_destroy(this->cdio), this->cdio = 0;
+        return false;
+    }
+
+    VERBOSE(VB_MEDIA+VB_EXTRA, QString("CdDecoder track=%1 lsn start=%2 end=%3").
+        arg(this->tracknum).arg(this->start).arg(this->end));
+    this->curpos = this->start;
+
+    this->device = cdio_cddap_identify_cdio(this->cdio, 0, NULL);
+    if (NULL == this->device)
+    {
+        VERBOSE(VB_IMPORTANT,
+            QString("Error: CdDecoder: cdio_cddap_identify(%1) failed").
+            arg(this->devicename));
+        cdio_destroy(this->cdio), this->cdio = 0;
+        return false;
+    }
+
+    cdio_cddap_verbose_set(this->device, 
+        VERBOSE_LEVEL_CHECK(VB_MEDIA) ? CDDA_MESSAGE_PRINTIT :
+            CDDA_MESSAGE_FORGETIT,
+        VERBOSE_LEVEL_CHECK(VB_MEDIA+VB_EXTRA) ? CDDA_MESSAGE_PRINTIT :
+            CDDA_MESSAGE_FORGETIT);
+
+    if (DRIVER_OP_SUCCESS == cdio_cddap_open(this->device))
+    {
+        // cdio_get_track_last_lsn is unreliable on discs with data at end
+        lsn_t end2 = cdio_cddap_track_lastsector(this->device, this->tracknum);
+        if (end2 < this->end)
+        {
+            VERBOSE(VB_MEDIA, QString("CdDecoder: trim last lsn from %1 to %2").
+                arg(this->end).arg(end2));
+            this->end = end2;
+        }
+
+        this->paranoia = cdio_paranoia_init(this->device);
+        if (NULL != this->paranoia)
+        {
+            cdio_paranoia_modeset(this->paranoia, PARANOIA_MODE_DISABLE);
+            (void)cdio_paranoia_seek(this->paranoia, this->start, SEEK_SET);
+        }
+        else
+        {
+            VERBOSE(VB_IMPORTANT, "Warn: CD reading with paranoia is disabled");
+        }
+    }
+    else
+    {
+        VERBOSE(VB_IMPORTANT,
+            QString("Warn: drive '%1' is not cdda capable").
+            arg(this->devicename));
+    }
+
+    int chnls = cdio_get_track_channels(this->cdio, this->tracknum);
+    this->chan = chnls > 0 ? chnls : 2;
+    this->freq = kSamplesPerSec;
+
+    if (output())
+    {
+        const AudioSettings settings(FORMAT_S16, this->chan,
+            CODEC_ID_PCM_S16LE, this->freq, false /* AC3/DTS passthru */);
+        output()->Reconfigure(settings);
+        output()->SetSourceBitrate(this->freq * this->chan * 16);
+    }
+
+    // 20ms worth
+    this->bks = (this->freq * this->chan * 2) / 50;
+    this->bksFrames = this->freq / 50;
+    // decode 8 bks worth of samples each time we need more
+    this->decodeBytes = this->bks << 3;
+
+    this->output_buf = reinterpret_cast< char* >(
+        ::av_malloc(this->decodeBytes + CDIO_CD_FRAMESIZE_RAW * 2));
+    this->output_at = 0;
+
+    setCDSpeed(2);
+
+    return this->inited = true;
+}
+
+// pure virtual
+void CdDecoder::seek(double pos)
+{
+    this->seekTime = pos;
+    if (output())
+        output()->PauseUntilBuffered();
+}
+
+// private
+void CdDecoder::deinit()
+{
+    setCDSpeed(-1);
+
+    QMutexLocker lock(&getCdioMutex());
+
+    if (this->paranoia)
+        cdio_paranoia_free(this->paranoia), this->paranoia = 0;
+    if (this->device)
+        cdio_cddap_close(this->device), this->device = 0, this->cdio = 0;
+    if (this->cdio)
+        cdio_destroy(this->cdio), this->cdio = 0;
+
+    if (this->output_buf)
+        ::av_free(this->output_buf), this->output_buf = NULL;
+
+    this->inited = this->user_stop = this->finish = false;
+    this->freq = this->bitrate = 0L;
+    this->stat = DecoderEvent::Finished;
+    this->chan = 0;
+    setInput(0);
+    setOutput(0);
+}
+
+// private
+void CdDecoder::run()
+{
+    if (!this->inited)
+        return;
+
+    this->stat = DecoderEvent::Decoding;
+    // NB block scope required to prevent re-entrancy
+    {
+        DecoderEvent e(this->stat);
+        dispatch(e);
+    }
+
+    // account for possible frame expansion in aobase (upmix, float conv)
+    const std::size_t thresh = this->bks * 6;
+
+    while (!this->finish && !this->user_stop)
+    {
+        if (this->seekTime >= +0.)
+        {
+            this->curpos = this->start + static_cast< lsn_t >(
+                (this->seekTime * kSamplesPerSec) / CD_FRAMESAMPLES);
+            if (this->paranoia)
+            {
+                QMutexLocker lock(&getCdioMutex());
+                cdio_paranoia_seek(this->paranoia, this->curpos, SEEK_SET);
+            }
+
+            this->output_at = 0;
+            this->seekTime = -1.;
+        }
+
+        if (this->output_at < this->bks)
+        {
+            while (this->output_at < this->decodeBytes &&
+                   !this->finish && !this->user_stop && this->seekTime <= +0.)
+            {
+                if (this->curpos < this->end)
+                {
+                    QMutexLocker lock(&getCdioMutex());
+                    if (this->paranoia)
+                    {
+                        int16_t *cdbuffer = cdio_paranoia_read(
+                                                this->paranoia, 0);
+                        if (cdbuffer)
+                            memcpy(&this->output_buf[this->output_at],
+                                cdbuffer, CDIO_CD_FRAMESIZE_RAW);
+                    }
+                    else
+                    {
+                        driver_return_code_t c = cdio_read_audio_sector(
+                            this->cdio, &this->output_buf[this->output_at],
+                            this->curpos);
+                        if (DRIVER_OP_SUCCESS != c)
+                        {
+                            VERBOSE(VB_MEDIA+VB_EXTRA,
+                                QString("cdio_read_audio_sector(%1) error %2").
+                                arg(this->curpos).arg(c));
+                            memset( &this->output_buf[this->output_at],
+                                0, CDIO_CD_FRAMESIZE_RAW);
+                        }
+                    }
+
+                    this->output_at += CDIO_CD_FRAMESIZE_RAW;
+                    ++(this->curpos);
+                }
+                else
+                {
+                    this->finish = true;
+                }
+            }
+        }
+
+        if (!output())
+            continue;
+
+        // Wait until we need to decode or supply more samples
+        uint fill = 0, total = 0;
+        while (!this->finish && !this->user_stop && this->seekTime <= +0.)
+        {
+            output()->GetBufferStatus(fill, total);
+            // Make sure we have decoded samples ready and that the
+            // audiobuffer is reasonably populated
+            if (fill < (thresh << 6))
+                break;
+            else
+            {
+                // Wait for half of the buffer to drain
+                ::usleep(output()->GetAudioBufferedTime()<<9);
+            }
+        }
+
+        // write a block if there's sufficient space for it
+        if (!this->user_stop &&
+            this->output_at >= this->bks &&
+            fill <= total - thresh)
+        {
+            writeBlock();
+        }
+    }
+
+    if (this->user_stop)
+        this->inited = false;
+    else if (output())
+    {
+        // Drain our buffer
+        while (this->output_at >= this->bks)
+            writeBlock();
+
+        // Drain ao buffer
+        output()->Drain();
+    }
+
+    if (this->finish)
+        this->stat = DecoderEvent::Finished;
+    else if (this->user_stop)
+        this->stat = DecoderEvent::Stopped;
+    else
+        this->stat = DecoderEvent::Error;
+
+    // NB block scope required to step onto next track
+    {
+        DecoderEvent e(this->stat);
+        dispatch(e);
+    }
+
+    deinit();
+}
+
+//public
+void CdDecoder::setCDSpeed(int speed)
+{
+    QMutexLocker lock(&getCdioMutex());
+
+    StCdioDevice cdio(this->devicename);
+    if (cdio)
+    {
+        driver_return_code_t c = cdio_set_speed(cdio, speed >= 0 ? speed : 1);
+        if (DRIVER_OP_SUCCESS != c)
+        {
+            VERBOSE(VB_MEDIA,
+                QString("Error: cdio_set_speed('%1',%2) failed").
+                arg(this->devicename).arg(speed));
+        }
+    }
+}
+
+//public
+int CdDecoder::getNumTracks()
+{
+    QMutexLocker lock(&getCdioMutex());
+
+    StCdioDevice cdio(this->devicename);
+    if (!cdio)
+        return 0;
+
+    track_t tracks = cdio_get_num_tracks(cdio);
+    if (CDIO_INVALID_TRACK != tracks)
+        VERBOSE(VB_MEDIA+VB_EXTRA, QString("getNumTracks = %1").arg(tracks));
+    else
+        tracks = -1;
+
+    return tracks;
+}
+
+//public
+int CdDecoder::getNumCDAudioTracks()
+{
+    QMutexLocker lock(&getCdioMutex());
+
+    StCdioDevice cdio(this->devicename);
+    if (!cdio)
+        return 0;
+
+    int nAudio = 0;
+    const track_t last = cdio_get_last_track_num(cdio);
+    if (CDIO_INVALID_TRACK != last)
+    {
+        for (track_t t = cdio_get_first_track_num(cdio) ; t <= last; ++t)
+        {
+            if (TRACK_FORMAT_AUDIO == cdio_get_track_format(cdio, t))
+                ++nAudio;
+        }
+        VERBOSE(VB_MEDIA+VB_EXTRA, QString("getNumCDAudioTracks = %1").arg(nAudio));
+    }
+    else
+      nAudio = -1;
+
+    return nAudio;
+}
+
+//public
+Metadata* CdDecoder::getMetadata(int track)
+{
+    this->settracknum = track;
+    return getMetadata();
+}
+
+//public
+Metadata *CdDecoder::getLastMetadata()
+{
+    for(int i = getNumTracks(); i > 0; --i)
+    {
+        Metadata *m = getMetadata(i);
+        if(m)
+            return m;
+    }
+    return NULL;
+}
+
+// Create a TOC
+static lsn_t s_lastAudioLsn;
+static Cddb::Toc& GetToc(CdIo_t *cdio, Cddb::Toc& toc)
+{
+    // Get lead-in
+    const track_t firstTrack = cdio_get_first_track_num(cdio);
+    lsn_t lsn0 = 0;
+    msf_t msf;
+    if (cdio_get_track_msf(cdio, firstTrack, &msf))
+        lsn0 = (msf.m * 60 + msf.s) * CDIO_CD_FRAMES_PER_SEC + msf.f;
+
+    const track_t lastTrack = cdio_get_last_track_num(cdio);
+    for (track_t t = firstTrack; t <= lastTrack + 1; ++t)
+    {
+#if 0 // This would be better but the msf's returned are way off in libcdio 0.81
+        if (!cdio_get_track_msf(cdio, t, &msf))
+            break;
+#else
+        lsn_t lsn = cdio_get_track_lsn(cdio, t);
+        if (s_lastAudioLsn && lsn > s_lastAudioLsn)
+            lsn = s_lastAudioLsn;
+        lsn += lsn0; // lead-in
+        
+        std::div_t d = std::div(lsn, CDIO_CD_FRAMES_PER_SEC);
+        msf.f = d.rem;
+        d = std::div(d.quot, 60);
+        msf.s = d.rem;
+        msf.m = d.quot;
+#endif
+        //VERBOSE(VB_MEDIA, QString("Track %1 msf: %2:%3:%4").
+        //    arg(t,2).arg(msf.m,2).arg(msf.s,2).arg(msf.f,2) );
+        toc.push_back(Cddb::Msf(msf.m, msf.s, msf.f));
+
+        if (TRACK_FORMAT_AUDIO != cdio_get_track_format(cdio, t))
+            break;
+    }
+    return toc;
+}
+
+//virtual
+Metadata *CdDecoder::getMetadata()
+{
+    QString artist, album, compilation_artist, title, genre;
+    int year = 0;
+    unsigned long length = 0;
+    track_t tracknum = 0;
+
+    if (-1 == this->settracknum)
+        tracknum = getFilename().toUInt();
+    else
+    {
+        tracknum = this->settracknum;
+        setFilename(QString("%1" CDEXT).arg(tracknum));
+    }
+
+    QMutexLocker lock(&getCdioMutex());
+
+    StCdioDevice cdio(this->devicename);
+    if (!cdio)
+        return NULL;
+
+    const track_t lastTrack = cdio_get_last_track_num(cdio);
+    if (CDIO_INVALID_TRACK == lastTrack)
+        return NULL;
+
+    if (TRACK_FORMAT_AUDIO != cdio_get_track_format(cdio, tracknum))
+        return NULL;
+
+    // Assume disc changed if max LSN different
+    bool isDiscChanged = false;
+    static lsn_t s_totalSectors;
+    lsn_t totalSectors = cdio_get_track_lsn(cdio, CDIO_CDROM_LEADOUT_TRACK);
+    if (s_totalSectors != totalSectors)
+    {
+        s_totalSectors = totalSectors;
+        isDiscChanged = true;
+    }
+
+    // NB cdio_get_track_last_lsn is unreliable for the last audio track
+    // of discs with data tracks beyond
+    lsn_t end = cdio_get_track_last_lsn(cdio, tracknum);
+    if (isDiscChanged)
+    {
+        const track_t audioTracks = getNumCDAudioTracks();
+        s_lastAudioLsn = cdio_get_track_last_lsn(cdio, audioTracks);
+
+        if (audioTracks < lastTrack)
+        {
+            cdrom_drive_t *dev = cdio_cddap_identify_cdio(cdio, 0, NULL);
+            if (NULL != dev)
+            {
+                if (DRIVER_OP_SUCCESS == cdio_cddap_open(dev))
+                {
+                    // NB this can be S L O W  but is reliable
+                    lsn_t end2 = cdio_cddap_track_lastsector(dev,
+                        getNumCDAudioTracks());
+                    if (CDIO_INVALID_LSN != end2)
+                        s_lastAudioLsn = end2;
+                }
+                cdio_cddap_close_no_free_cdio(dev);
+            }
+        }
+    }
+
+    if (s_lastAudioLsn && s_lastAudioLsn < end)
+        end = s_lastAudioLsn;
+
+    const lsn_t start = cdio_get_track_lsn(cdio, tracknum);
+    if (CDIO_INVALID_LSN != start && CDIO_INVALID_LSN != end)
+    {
+        length = ((end - start + 1) * 1000 + CDIO_CD_FRAMES_PER_SEC/2) /
+            CDIO_CD_FRAMES_PER_SEC;
+    }
+
+    bool isCompilation = false;
+
+#define CDTEXT 0 // Disabled - cd-text access on discs without it is S L O W
+#if CDTEXT
+    static int s_iCdtext;
+    if (isDiscChanged)
+        s_iCdtext = -1;
+
+    if (s_iCdtext)
+    {
+        // cdio_get_cdtext can't take >5 seconds on some CD's without cdtext
+        if (s_iCdtext < 0)
+            VERBOSE(VB_MEDIA,
+                QString("Getting cdtext for track %1...").arg(tracknum));
+        cdtext_t * cdtext = cdio_get_cdtext(cdio, tracknum);
+        if (NULL != cdtext)
+        {
+            genre = cdtext_get_const(CDTEXT_GENRE, cdtext);
+            artist = cdtext_get_const(CDTEXT_PERFORMER, cdtext);
+            title = cdtext_get_const(CDTEXT_TITLE, cdtext);
+            const char* isrc = cdtext_get_const(CDTEXT_ISRC, cdtext);
+            /* ISRC codes are 12 characters long, in the form CCXXXYYNNNNN
+             * CC = country code
+             * XXX = registrant e.g. BMG
+             * CC = year withou century
+             * NNNNN = unique ID
+             */
+            if (isrc && strlen(isrc) >= 7)
+            {
+                year = (isrc[5] - '0') * 10 + (isrc[6] - '0');
+                year += (year <= 30) ? 2000 : 1900;
+            }
+
+            cdtext_destroy(cdtext);
+
+            if (!title.isNull())
+            {
+                if (s_iCdtext < 0)
+                    VERBOSE(VB_MEDIA, "Found cdtext track title");
+                s_iCdtext = 1;
+
+                // Get disc info
+                cdtext = cdio_get_cdtext(cdio, 0);
+                if (NULL != cdtext)
+                {
+                    compilation_artist = cdtext_get_const(
+                        CDTEXT_PERFORMER, cdtext);
+                    if (!compilation_artist.isEmpty() &&
+                            artist != compilation_artist)
+                        isCompilation = true;
+
+                    album = cdtext_get_const(CDTEXT_TITLE, cdtext);
+
+                    if (genre.isNull())
+                        genre = cdtext_get_const(CDTEXT_GENRE, cdtext);
+
+                    cdtext_destroy(cdtext);
+                }
+            }
+            else
+            {
+                if (s_iCdtext < 0)
+                    VERBOSE(VB_MEDIA, "No cdtext title for track");
+                s_iCdtext = 0;
+            }
+        }
+        else
+        {
+            if (s_iCdtext < 0)
+                VERBOSE(VB_MEDIA, "No cdtext");
+            s_iCdtext = 0;
+        }
+    }
+
+    if (title.isEmpty() || artist.isEmpty() || album.isEmpty())
+#endif // CDTEXT
+    {
+        // CDDB lookup
+        Cddb::Toc toc;
+        Cddb::Matches r;
+        if (Cddb::Query(r, GetToc(cdio, toc)))
+        {
+            Cddb::Matches::match_t::const_iterator select = r.matches.begin();
+
+            if (r.matches.size() > 1)
+            {
+                // TODO prompt user to select one
+                // In the meantime, select the first non-generic genre
+                for (Cddb::Matches::match_t::const_iterator it = select;
+                    it != r.matches.end(); ++it)
+                {
+                    QString g = it->genre.toLower();
+                    if (g != "misc" && g != "data")
+                    {
+                        select = it;
+                        break;
+                    }
+                }
+            }
+
+            Cddb::Album info;
+            if (Cddb::Read(info, select->genre, select->discID))
+            {
+                isCompilation = info.isCompilation;
+                if (info.genre.toLower() != "misc")
+                    genre = info.genre;
+                album = info.title;
+                compilation_artist = info.artist;
+                year = info.year;
+                if (info.tracks.size() >= tracknum)
+                {
+                    const Cddb::Track& track = info.tracks[tracknum - 1];
+                    title = track.title;
+                    artist = track.artist;
+                }
+
+                // Create a temporary local alias for future lookups
+                if (r.discID != info.discID)
+                    Cddb::Alias(info, r.discID);
+            }
+        }
+    }
+
+    if (compilation_artist.toLower().left(7) == "various")
+        compilation_artist = QObject::tr("Various Artists");
+
+    if (artist.isEmpty())
+    {
+        artist = compilation_artist;
+        compilation_artist.clear();
+    }
+
+    if (title.isEmpty())
+        title = QObject::tr("Track %1").arg(tracknum);
+
+    Metadata *m = new Metadata(getFilename(), artist, compilation_artist,
+        album, title, genre, year, tracknum, length);
+    if (m)
+        m->setCompilation(isCompilation);
+
+    return m;
+}
+
+// virtual
+void CdDecoder::commitMetadata(Metadata *mdata)
+{
+    QMutexLocker lock(&getCdioMutex());
+
+    StCdioDevice cdio(this->devicename);
+    if (!cdio)
+        return;
+
+    Cddb::Toc toc;
+    GetToc(cdio, toc);
+
+    unsigned secs;
+    Cddb::discid_t discID = Cddb::Discid(secs, toc.data(), toc.size() - 1);
+
+    Cddb::Album album(discID, mdata->Genre().toLower().toUtf8());
+    if (!Cddb::Read(album, album.genre, discID))
+        album.toc = toc;
+
+    album.isCompilation = mdata->Compilation();
+    if (!mdata->Compilation())
+        album.artist = mdata->Artist();
+    else if (mdata->CompilationArtist() != album.artist)
+        album.artist = mdata->CompilationArtist();
+
+    album.title = mdata->Album();
+    album.year = mdata->Year();
+
+    if (album.tracks.size() < this->tracknum)
+        album.tracks.resize(this->tracknum);
+
+    Cddb::Track& track = album.tracks[this->tracknum - 1];
+    track.title = mdata->Title();
+    track.artist = mdata->Artist();
+
+    Cddb::Write(album);
+}
+
+
+// pure virtual
+bool CdDecoderFactory::supports(const QString &source) const
+{
+    return (source.right(extension().length()).toLower() == extension());
+}
+
+// pure virtual
+const QString &CdDecoderFactory::extension() const
+{
+    static QString ext(CDEXT);
+    return ext;
+}
+
+// pure virtual
+const QString &CdDecoderFactory::description() const
+{
+    static QString desc(QObject::tr("Audio CD parser"));
+    return desc;
+}
+
+// pure virtual
+Decoder *CdDecoderFactory::create(const QString &file, QIODevice *input,
+                                  AudioOutput *output, bool deletable)
+{
+   if (deletable)
+        return new CdDecoder(file, this, input, output);
+
+    static CdDecoder *decoder;
+    if (! decoder) {
+        decoder = new CdDecoder(file, this, input, output);
+    } else {
+        decoder->setInput(input);
+        decoder->setFilename(file);
+        decoder->setOutput(output);
+    }
+
+    return decoder;
+}

mythplugins/mythmusic/mythmusic/cddecoder.cpp

@@ -37 +37 @@
     m_lastTrack(0),  m_leadout(0),
     m_lengthInSecs(0.0)
 #endif
-    stat(0),         output_buf(NULL),
+    stat(DecoderEvent::Error),
+    output_buf(NULL),
     output_at(0),    bks(0),
     bksFrames(0),    decodeBytes(0),
     finish(false),
@@ -45 +46 @@
     chan(0),
     totalTime(0.0),  seekTime(-1.0),
     settracknum(-1), tracknum(0),
-#if defined(__linux__) || defined(__FreeBSD__)
+#ifdef HAVE_PARANOIA
     device(NULL),    paranoia(NULL),
 #endif
     start(0),        end(0),
@@ -85 +86 @@
 {
     inited = user_stop = finish = FALSE;
     freq = bitrate = 0;
-    stat = chan = 0;
+    stat = DecoderEvent::Error;
+    chan = 0;
     seekTime = -1.0;
 
     if (output())
@@ -96 +98 @@
     filename = ((QFile *)input())->fileName();
     tracknum = filename.section('.', 0, 0).toUInt();
 
+#ifdef HAVE_PARANOIA
     QByteArray devname = devicename.toAscii();
     device = cdda_identify(devname.constData(), 0, NULL);
     if (!device)
@@ -148 +151 @@
     setCDSpeed(2);
     inited = TRUE;
     return TRUE;
+#else
+    return FALSE;
+#endif
 }
 
 void CdDecoder::seek(double pos)
@@ -159 +165 @@
 
 void CdDecoder::deinit()
 {
+#ifdef HAVE_PARANOIA
     setCDSpeed(-1);
     if (paranoia)
         paranoia_free(paranoia);
@@ -171 +178 @@
 
     device = NULL;
     paranoia = NULL;
+#endif
 
     inited = user_stop = finish = FALSE;
     freq = bitrate = 0;
-    stat = chan = 0;
+    stat = DecoderEvent::Error;
+    chan = 0;
     setInput(0);
     setOutput(0);
 }
 
+#ifdef HAVE_PARANOIA
 static void paranoia_cb(long inpos, int function)
 {
     inpos = inpos; function = function;
 }
+#endif
 
 void CdDecoder::run()
 {
@@ -205 +216 @@
         if (seekTime >= 0.0)
         {
             curpos = (int)(((seekTime * 44100) / CD_FRAMESAMPLES) + start);
+#ifdef HAVE_PARANOIA
             paranoia_seek(paranoia, curpos, SEEK_SET);
+#endif
             output_at = 0;
             seekTime = -1.0;
         }
@@ -219 +232 @@
 
                 if (curpos <= end)
                 {
+#ifdef HAVE_PARANOIA
                     cdbuffer = paranoia_read(paranoia, paranoia_cb);
 
                     memcpy((char *)(output_buf + output_at), (char *)cdbuffer,
                            CD_FRAMESIZE_RAW);
+#endif
 
                     output_at += CD_FRAMESIZE_RAW;
                 }
@@ -286 +301 @@
 
 int CdDecoder::getNumTracks(void)
 {
+#ifdef HAVE_CDAUDIO
     QByteArray devname = devicename.toAscii();
     int cd = cd_init_device(const_cast<char*>(devname.constData()));
 
@@ -309 +325 @@
     cd_finish(cd);
 
     return retval;
+#else
+    return 0;
+#endif
 }
 
 int CdDecoder::getNumCDAudioTracks(void)
 {
+#ifdef HAVE_CDAUDIO
     QByteArray devname = devicename.toAscii();
     int cd = cd_init_device(const_cast<char*>(devname.constData()));
 
@@ -343 +363 @@
     cd_finish(cd);
 
     return retval;
+#else
+    return 0;
+#endif
 }
 
 Metadata* CdDecoder::getMetadata(int track)
@@ -372 +395 @@
     QString artist, album, compilation_artist, title, genre;
     int year = 0, tracknum = 0, length = 0;
 
+#ifdef HAVE_CDAUDIO
     QByteArray devname = devicename.toAscii();
     int cd = cd_init_device(const_cast<char*>(devname.constData()));
 
@@ -466 +490 @@
     length = length < 0 ? 0 : length;
     length *= 1000;
 
+    cd_finish(cd);
+#endif // defined HAVE_CDAUDIO
+
     Metadata *retdata = new Metadata(filename, artist, compilation_artist,
                                      album, title, genre, year, tracknum, length);
 
-    retdata->determineIfCompilation(true);
+    if (retdata)
+        retdata->determineIfCompilation(true);
 
-    cd_finish(cd);
     return retdata;
 }
 
+#ifdef HAVE_CDAUDIO
 static void set_cstring(char *dest, const char *src, size_t dest_buf_size)
 {
     if (dest_buf_size < 1)
@@ -482 +510 @@
     strncpy(dest, src, dest_buf_size - 1);
     dest[dest_buf_size - 1] = 0;
 }
+#endif
 
 void CdDecoder::commitMetadata(Metadata *mdata)
 {
+#ifdef HAVE_CDAUDIO
     QByteArray devname = devicename.toAscii();
     int cd = cd_init_device(const_cast<char*>(devname.constData()));
 
@@ -566 +596 @@
     cddb_write_data(cd, &discdata);
 
     cd_finish(cd);
+#else
+    (void)mdata;
+#endif
 }
 
 bool CdDecoderFactory::supports(const QString &source) const