Merge lp:~mixxxdevelopers/mixxx/features_flac into lp:~mixxxdevelopers/mixxx/trunk

[William Good]

Adds a new SoundSource using libFLAC. Written to replace Mixxx's use of libsndfile for FLAC due to the bugs linked to this branch.

[lp:~mixxxdevelopers/mixxx/features_flac]

2416. By William Good on 2010-07-27

Changed qDebugs to qWarnings as necessary and broke up some way-long lines.

2417. By William Good on 2010-07-27

Fixed memory allocation bug (was allocating based on number of channels when
    it really uses 2 samples per frame no matter the number of channels).

[William Good (bkgood)]

Tested and works with all the FLAC files generated by the file format script in src/test.

[lp:~mixxxdevelopers/mixxx/features_flac]

2418. By William Good on 2010-08-16

Marking a todo (code cleanup before taking a diff for gsoc)

2419. By William Good on 2010-08-16

Merging with trunk

2420. By William Good on 2010-10-19

Merging from lp:mixxx

[Albert Santoni (gamegod)]

+ setBitrate(m_iSampleRate * 16 * m_iChannels / 1000); // 16 = bps

- Should that be 1024 instead of 1000? Hardcoded bit depth too. Where do you tell FLAC that you want 16-bit samples? Can you make this a constant at least?

+inline int SoundSourceFLAC::getShift() const {
- same hardcoded 16 constant?

- How do you deal with 24-bit FLAC files?

parseHeader():
- This is some undocumented bad news: parseHeader() has to be re-entrant. You can't use the existing file handle, because it can get called after an open() on an existing SoundSource object. This is the most important thing to fix.

review: Needs Fixing

[William Good (bkgood)]

> + setBitrate(m_iSampleRate * 16 * m_iChannels / 1000); // 16 = bps
>
> - Should that be 1024 instead of 1000? Hardcoded bit depth too. Where do you
> tell FLAC that you want 16-bit samples? Can you make this a constant at least?
>
I believe it should be 1000 as setBitrate is supposed to get its argument in
kbits/s (according to the wiki SoundSource page). Fixed the hardcoded bps
thing, that was left over from when I only did 16-bit. FLAC gives me whatever
size samples are in the file, then I shift them to 16-bit since that's what
Mixxx wants.

SSSndfile uses setBitrate(samplerate*32/1000).

> +inline int SoundSourceFLAC::getShift() const {
> - same hardcoded 16 constant?
>
> - How do you deal with 24-bit FLAC files?
>
The sample value is shifted so that the sample fits in a 16-bit short.
getShift gives the number of places needed to shift the sample in order
to make the sample fit in 16 bits (so 24-bit samples are shifted right
abs(16-bps) times and <16-bit samples are shifted left 16-bps times),
which is the meaning of the constant (doxygen-style comment above the
method kinda explains this). shift() is then called on every sample to
normalize it to 16-bits using a shift amount/direction from getShift.
See ::flacWrite().

>
> parseHeader():
> - This is some undocumented bad news: parseHeader() has to be re-entrant. You
> can't use the existing file handle, because it can get called after an open()
> on an existing SoundSource object. This is the most important thing to fix.
I believe this is now fixed.

[lp:~mixxxdevelopers/mixxx/features_flac]

2421. By William Good on 2010-11-11

Made SSFLAC::parseHeader re-entrant. Commented/fixed some magic numbers.

2422. By William Good on 2010-11-11

Silenced some debugs

2423. By William Good on 2010-11-11

Merged from lp:mixxx

2424. By William Good on 2010-11-11

Switched SSFLAC to using TagLib for metadata parsing

2425. By William Good on 2010-11-14

Copied FLAC filename to QByteArray before passing to TagLib for safety

2426. By William Good on 2010-11-14

Merged from lp:mixxx

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2010-11-02 19:50:15 +0000
+++ mixxx/build/depends.py	2010-11-14 02:21:19 +0000
@@ -100,6 +100,18 @@
     def sources(self, build):
         return ['soundsourcesndfile.cpp']
 
+class FLAC(Dependence):
+    def configure(self, build, conf):
+        if not conf.CheckHeader('FLAC/stream_decoder.h'):
+            raise Exception('Did not find libFLAC development headers, exiting!')
+        elif not conf.CheckLib(['libFLAC', 'FLAC']):
+            raise Exception('Did not find libFLAC development libraries, exiting!')
+        return
+
+    def sources(self, build):
+        return ['soundsourceflac.cpp',]
+
+
 class Qt(Dependence):
     DEFAULT_QTDIRS = {'linux': '/usr/share/qt4',
                       'bsd': '/usr/local/lib/qt4',
@@ -681,7 +693,7 @@
 
     def depends(self, build):
         return [SoundTouch, KissFFT, PortAudio, PortMIDI, Qt,
-                FidLib, Mad, SndFile, OggVorbis, OpenGL, TagLib]
+                FidLib, Mad, SndFile, FLAC, OggVorbis, OpenGL, TagLib]
 
     def post_dependency_check_configure(self, build, conf):
         """Sets up additional things in the Environment that must happen

=== added file 'mixxx/src/soundsourceflac.cpp'
--- mixxx/src/soundsourceflac.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/soundsourceflac.cpp	2010-11-14 02:21:19 +0000
@@ -0,0 +1,374 @@
+/**
+ * \file soundsourceflac.cpp
+ * \author Bill Good <bkgood at gmail dot com>
+ * \date May 22, 2010
+ */
+
+/***************************************************************************
+ *                                                                         *
+ *   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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <cstring> // memcpy
+#include <QtDebug>
+#include <taglib/flacfile.h>
+
+#include "soundsourceflac.h"
+
+SoundSourceFLAC::SoundSourceFLAC(QString filename)
+    : SoundSource(filename)
+    , m_file(filename)
+    , m_decoder(NULL)
+    , m_samples(0)
+    , m_bps(0)
+    , m_flacBuffer(NULL)
+    , m_flacBufferLength(0)
+    , m_leftoverBuffer(NULL)
+    , m_leftoverBufferLength(0) {
+}
+
+SoundSourceFLAC::~SoundSourceFLAC() {
+    if (m_flacBuffer != NULL) {
+        delete [] m_flacBuffer;
+        m_flacBuffer = NULL;
+    }
+    if (m_leftoverBuffer != NULL) {
+        delete [] m_leftoverBuffer;
+        m_leftoverBuffer = NULL;
+    }
+    if (m_decoder) {
+        FLAC__stream_decoder_finish(m_decoder);
+        FLAC__stream_decoder_delete(m_decoder); // frees memory
+        m_decoder = NULL; // probably not necessary
+    }
+}
+
+// soundsource overrides
+int SoundSourceFLAC::open() {
+    m_file.open(QIODevice::ReadOnly);
+    m_decoder = FLAC__stream_decoder_new();
+    if (m_decoder == NULL) {
+        qWarning() << "SSFLAC: decoder allocation failed!";
+        return ERR;
+    }
+    if (!FLAC__stream_decoder_set_metadata_respond(m_decoder,
+                FLAC__METADATA_TYPE_VORBIS_COMMENT)) {
+        qWarning() << "SSFLAC: set metadata respond to vorbis comments failed";
+        goto decoderError;
+    }
+    FLAC__StreamDecoderInitStatus initStatus;
+    initStatus = FLAC__stream_decoder_init_stream(
+        m_decoder, FLAC_read_cb, FLAC_seek_cb, FLAC_tell_cb, FLAC_length_cb,
+        FLAC_eof_cb, FLAC_write_cb, FLAC_metadata_cb, FLAC_error_cb,
+        (void*) this);
+    if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
+        qWarning() << "SSFLAC: decoder init failed!";
+        goto decoderError;
+    }
+    if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
+        qWarning() << "SSFLAC: process to end of meta failed!";
+        qWarning() << "SSFLAC: decoder state: " << FLAC__stream_decoder_get_state(m_decoder);
+        goto decoderError;
+    } // now number of samples etc. should be populated
+    if (m_flacBuffer == NULL) {
+        // we want 2 samples per frame, see ::flacWrite code -- bkgood
+        m_flacBuffer = new FLAC__int16[m_maxBlocksize * 2 /*m_iChannels*/];
+    }
+    if (m_leftoverBuffer == NULL) {
+        m_leftoverBuffer = new FLAC__int16[m_maxBlocksize * 2 /*m_iChannels*/];
+    }
+//    qDebug() << "SSFLAC: Total samples: " << m_samples;
+//    qDebug() << "SSFLAC: Sampling rate: " << m_iSampleRate << " Hz";
+//    qDebug() << "SSFLAC: Channels: " << m_iChannels;
+//    qDebug() << "SSFLAC: BPS: " << m_bps;
+    return OK;
+decoderError:
+    FLAC__stream_decoder_finish(m_decoder);
+    FLAC__stream_decoder_delete(m_decoder);
+    m_decoder = NULL;
+    return ERR;
+}
+
+long SoundSourceFLAC::seek(long filepos) {
+    if (!m_decoder) return 0;
+    FLAC__bool seekResult;
+    // important division here, filepos is in audio samples (i.e. shorts)
+    // but libflac expects a number in time samples. I _think_ this should
+    // be hard-coded at two because *2 is the assumption the caller makes
+    // -- bkgood
+    seekResult = FLAC__stream_decoder_seek_absolute(m_decoder, filepos / 2);
+    m_leftoverBufferLength = 0; // clear internal buffer since we moved
+    return filepos;
+}
+
+unsigned int SoundSourceFLAC::read(unsigned long size, const SAMPLE *destination) {
+    if (!m_decoder) return 0;
+    SAMPLE *destBuffer = const_cast<SAMPLE*>(destination);
+    unsigned int samplesWritten = 0;
+    unsigned int i = 0;
+    while (samplesWritten < size) {
+        // if our buffer from libflac is empty (either because we explicitly cleared
+        // it or because we've simply used all the samples), ask for a new buffer
+        if (m_flacBufferLength == 0) {
+            i = 0;
+            if (!FLAC__stream_decoder_process_single(m_decoder)) {
+                qWarning() << "SSFLAC: decoder_process_single returned false";
+                break;
+            } else if (m_flacBufferLength == 0) {
+                // EOF
+                break;
+            }
+        }
+        destBuffer[samplesWritten++] = m_flacBuffer[i++];
+        --m_flacBufferLength;
+    }
+    if (m_flacBufferLength != 0) {
+        memcpy(m_leftoverBuffer, &m_flacBuffer[i],
+                m_flacBufferLength * sizeof(m_flacBuffer[0])); // safe because leftoverBuffer
+                                                               // is as long as flacbuffer
+        memcpy(m_flacBuffer, m_leftoverBuffer,
+                m_flacBufferLength * sizeof(m_leftoverBuffer[0]));
+        // this whole if block could go away if this just used a ring buffer but I'd
+        // rather do that after I've gotten off the inital happiness of getting this right,
+        // if I see SIGSEGV one more time I'll pop -- bkgood
+    }
+    return samplesWritten;
+}
+
+inline unsigned long SoundSourceFLAC::length() {
+    return m_samples * m_iChannels;
+}
+
+int SoundSourceFLAC::parseHeader() {
+    setType("flac");
+    QByteArray fileName(m_file.fileName().toUtf8());
+    TagLib::FLAC::File f(fileName.constData());
+    bool result = processTaglibFile(f);
+    TagLib::ID3v2::Tag *id3v2 = f.ID3v2Tag();
+    TagLib::Ogg::XiphComment *xiph = f.xiphComment();
+    if (id3v2) {
+        processID3v2Tag(id3v2);
+    }
+    if (xiph) {
+        processXiphComment(xiph);
+    }
+    return result ? OK : ERR;
+}
+
+void SoundSourceFLAC::setTag(const QString &tag) {
+    QString key = tag.left(tag.indexOf("=")).toUpper();
+    QString value = tag.right(tag.length() - tag.indexOf("=") - 1);
+    // standard here: http://www.xiph.org/vorbis/doc/v-comment.html
+    if (key == "ARTIST") {
+        m_sArtist = value;
+    } else if (key == "TITLE") {
+        m_sTitle = value;
+    } else if (key == "ALBUM") {
+        m_sAlbum = value;
+    } else if (key == "COMMENT") { // this doesn't exist in standard vorbis comments
+        m_sComment = value;
+    } else if (key == "DATE") {
+        m_sYear = value;
+    } else if (key == "GENRE") {
+        m_sGenre = value;
+    } else if (key == "TRACKNUMBER") {
+        m_sTrackNumber = value;
+    } else if (key == "BPM") { // this doesn't exist in standard vorbis comments
+        m_fBPM = value.toFloat();
+    }
+}
+
+/**
+ * Shift needed to take our FLAC sample size to Mixxx's 16-bit samples.
+ * Shift right on negative, left on positive.
+ */
+inline int SoundSourceFLAC::getShift() const {
+    return 16 - m_bps;
+}
+
+/**
+ * Shift a sample from FLAC as necessary to get a 16-bit value.
+ */
+inline FLAC__int16 SoundSourceFLAC::shift(FLAC__int32 sample) const {
+    // this is how libsndfile does this operation and is wonderfully
+    // straightforward. Just shift the sample left or right so that
+    // it fits in a 16-bit short. -- bkgood
+    int shift = getShift();
+    if (shift == 0) {
+        return sample;
+    } else if (shift < 0) {
+        return sample >> abs(shift);
+    } else {
+        return sample << shift;
+    }
+};
+
+// static
+QList<QString> SoundSourceFLAC::supportedFileExtensions() {
+    QList<QString> list;
+    list.push_back("flac");
+    return list;
+}
+
+
+// flac callback methods
+FLAC__StreamDecoderReadStatus SoundSourceFLAC::flacRead(FLAC__byte buffer[], size_t *bytes) {
+    *bytes = m_file.read((char*) buffer, *bytes);
+    if (*bytes > 0) {
+        return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
+    } else if (*bytes == 0) {
+        return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
+    } else {
+        return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
+    }
+}
+
+FLAC__StreamDecoderSeekStatus SoundSourceFLAC::flacSeek(FLAC__uint64 offset) {
+    if (m_file.seek(offset)) {
+        return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
+    } else {
+        return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
+    }
+}
+
+FLAC__StreamDecoderTellStatus SoundSourceFLAC::flacTell(FLAC__uint64 *offset) {
+    if (m_file.isSequential()) {
+        return FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED;
+    }
+    *offset = m_file.pos();
+    return FLAC__STREAM_DECODER_TELL_STATUS_OK;
+}
+
+FLAC__StreamDecoderLengthStatus SoundSourceFLAC::flacLength(FLAC__uint64 *length) {
+    if (m_file.isSequential()) {
+        return FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED;
+    }
+    *length = m_file.size();
+    return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
+}
+
+FLAC__bool SoundSourceFLAC::flacEOF() {
+    if (m_file.isSequential()) {
+        return false;
+    }
+    return m_file.atEnd();
+}
+
+FLAC__StreamDecoderWriteStatus SoundSourceFLAC::flacWrite(const FLAC__Frame *frame,
+        const FLAC__int32 *const buffer[]) {
+    unsigned int i;
+    m_flacBufferLength = 0;
+    if (frame->header.channels > 1) {
+        // stereo (or greater)
+        for (i = 0; i < frame->header.blocksize; ++i) {
+            m_flacBuffer[m_flacBufferLength++] = shift(buffer[0][i]); // left channel
+            m_flacBuffer[m_flacBufferLength++] = shift(buffer[1][i]); // right channel
+        }
+    } else {
+        // mono
+        for (i = 0; i < frame->header.blocksize; ++i) {
+            m_flacBuffer[m_flacBufferLength++] = shift(buffer[0][i]); // left channel
+            m_flacBuffer[m_flacBufferLength++] = shift(buffer[0][i]); // mono channel
+        }
+    }
+    return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; // can't anticipate any errors here
+}
+
+void SoundSourceFLAC::flacMetadata(const FLAC__StreamMetadata *metadata) {
+    switch (metadata->type) {
+    case FLAC__METADATA_TYPE_STREAMINFO:
+        m_samples = metadata->data.stream_info.total_samples;
+        m_iChannels = metadata->data.stream_info.channels;
+        m_iSampleRate = metadata->data.stream_info.sample_rate;
+        m_bps = metadata->data.stream_info.bits_per_sample;
+        m_minBlocksize = metadata->data.stream_info.min_blocksize;
+        m_maxBlocksize = metadata->data.stream_info.max_blocksize;
+        m_minFramesize = metadata->data.stream_info.min_framesize;
+        m_maxFramesize = metadata->data.stream_info.max_framesize;
+//        qDebug() << "FLAC file " << m_qFilename;
+//        qDebug() << m_iChannels << " @ " << m_iSampleRate << " Hz, " << m_samples
+//            << " total, " << m_bps << " bps";
+//        qDebug() << "Blocksize in [" << m_minBlocksize << ", " << m_maxBlocksize
+//            << "], Framesize in [" << m_minFramesize << ", " << m_maxFramesize << "]";
+        break;
+    case FLAC__METADATA_TYPE_VORBIS_COMMENT:
+        for (unsigned int i = 0; i < metadata->data.vorbis_comment.num_comments; ++i) {
+            m_tags.append(QString::fromUtf8(
+                        (const char*) metadata->data.vorbis_comment.comments[i].entry,
+                        metadata->data.vorbis_comment.comments[i].length));
+        }
+        break;
+    default:
+        // don't care, and libflac won't send us any others anyway...
+        break;
+    }
+}
+
+void SoundSourceFLAC::flacError(FLAC__StreamDecoderErrorStatus status) {
+    QString error;
+    // not much can be done at this point -- luckly the decoder seems to be
+    // pretty forgiving -- bkgood
+    switch (status) {
+    case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
+        error = "STREAM_DECODER_ERROR_STATUS_LOST_SYNC";
+        break;
+    case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
+        error = "STREAM_DECODER_ERROR_STATUS_BAD_HEADER";
+        break;
+    case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
+        error = "STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH";
+        break;
+    case FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM:
+        error = "STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM";
+        break;
+    }
+    qWarning() << "SSFLAC got error" << error << "from libFLAC for file"
+        << m_file.fileName();
+    // not much else to do here... whatever function that initiated whatever
+    // decoder method resulted in this error will return an error, and the caller
+    // will bail. libFLAC docs say to not close the decoder here -- bkgood
+}
+
+// begin callbacks (have to be regular functions because normal libFLAC isn't C++-aware)
+
+FLAC__StreamDecoderReadStatus FLAC_read_cb(const FLAC__StreamDecoder*, FLAC__byte buffer[],
+        size_t *bytes, void *client_data) {
+    return ((SoundSourceFLAC*) client_data)->flacRead(buffer, bytes);
+}
+
+FLAC__StreamDecoderSeekStatus FLAC_seek_cb(const FLAC__StreamDecoder*,
+        FLAC__uint64 absolute_byte_offset, void *client_data) {
+    return ((SoundSourceFLAC*) client_data)->flacSeek(absolute_byte_offset);
+}
+
+FLAC__StreamDecoderTellStatus FLAC_tell_cb(const FLAC__StreamDecoder*,
+        FLAC__uint64 *absolute_byte_offset, void *client_data) {
+    return ((SoundSourceFLAC*) client_data)->flacTell(absolute_byte_offset);
+}
+
+FLAC__StreamDecoderLengthStatus FLAC_length_cb(const FLAC__StreamDecoder*,
+        FLAC__uint64 *stream_length, void *client_data) {
+    return ((SoundSourceFLAC*) client_data)->flacLength(stream_length);
+}
+
+FLAC__bool FLAC_eof_cb(const FLAC__StreamDecoder*, void *client_data) {
+    return ((SoundSourceFLAC*) client_data)->flacEOF();
+}
+
+FLAC__StreamDecoderWriteStatus FLAC_write_cb(const FLAC__StreamDecoder*, const FLAC__Frame *frame,
+        const FLAC__int32 *const buffer[], void *client_data) {
+    return ((SoundSourceFLAC*) client_data)->flacWrite(frame, buffer);
+}
+
+void FLAC_metadata_cb(const FLAC__StreamDecoder*, const FLAC__StreamMetadata *metadata, void *client_data) {
+    ((SoundSourceFLAC*) client_data)->flacMetadata(metadata);
+}
+
+void FLAC_error_cb(const FLAC__StreamDecoder*, FLAC__StreamDecoderErrorStatus status, void *client_data) {
+    ((SoundSourceFLAC*) client_data)->flacError(status);
+}
+// end callbacks

=== added file 'mixxx/src/soundsourceflac.h'
--- mixxx/src/soundsourceflac.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/soundsourceflac.h	2010-11-14 02:21:19 +0000
@@ -0,0 +1,87 @@
+/**
+ * \file sourdsourceflac.h
+ * \class SoundSourceFLAC
+ * \brief Decodes FLAC files using libFLAC for Mixxx.
+ * \author Bill Good <bkgood at gmail dot com>
+ * \date May 22, 2010
+ */
+
+/***************************************************************************
+ *                                                                         *
+ *   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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef SOUNDSOURCEFLAC_H
+#define SOUNDSOURCEFLAC_H
+
+#include <QFile>
+#include <QString>
+#include <FLAC/stream_decoder.h>
+
+#include "defs.h"
+#include "soundsource.h"
+
+class TrackInfoObject;
+
+class SoundSourceFLAC : public SoundSource {
+public:
+    SoundSourceFLAC(QString filename);
+    ~SoundSourceFLAC();
+    int open();
+    long seek(long filepos);
+    unsigned read(unsigned long size, const SAMPLE *buffer);
+    inline long unsigned length();
+    int parseHeader();
+    static QList<QString> supportedFileExtensions();
+    // callback methods
+    FLAC__StreamDecoderReadStatus flacRead(FLAC__byte buffer[], size_t *bytes);
+    FLAC__StreamDecoderSeekStatus flacSeek(FLAC__uint64 offset);
+    FLAC__StreamDecoderTellStatus flacTell(FLAC__uint64 *offset);
+    FLAC__StreamDecoderLengthStatus flacLength(FLAC__uint64 *length);
+    FLAC__bool flacEOF();
+    FLAC__StreamDecoderWriteStatus flacWrite(const FLAC__Frame *frame, const FLAC__int32 *const buffer[]);
+    void flacMetadata(const FLAC__StreamMetadata *metadata);
+    void flacError(FLAC__StreamDecoderErrorStatus status);
+private:
+    void setTag(const QString &tag);
+    // these next two are inline but are defined in the cpp file because
+    // they should only be used there -- bkgood
+    inline int getShift() const;
+    inline FLAC__int16 shift(const FLAC__int32 sample) const;
+    QFile m_file;
+    FLAC__StreamDecoder *m_decoder;
+    FLAC__StreamMetadata_StreamInfo *m_streamInfo;
+    unsigned int m_samples; // total number of samples
+    unsigned int m_bps; // bits per sample
+    // misc bits about the flac format:
+    // flac encodes from and decodes to LPCM in blocks, each block is made up of
+    // subblocks (one for each chan)
+    // flac stores in 'frames', each of which has a header and a certain number
+    // of subframes (one for each channel)
+    unsigned int m_minBlocksize; // in time samples (audio samples = time samples * chanCount)
+    unsigned int m_maxBlocksize;
+    unsigned int m_minFramesize;
+    unsigned int m_maxFramesize;
+    FLAC__int16 *m_flacBuffer; // buffer for the write callback to write a single frame's samples
+    unsigned int m_flacBufferLength;
+    FLAC__int16 *m_leftoverBuffer; // buffer to place any samples which haven't been used
+                                   // at the end of a read call
+    unsigned int m_leftoverBufferLength;
+    QList<QString> m_tags; // stored in vorbis comment format as received, ex. "ARTIST=blah"
+};
+
+// callbacks for libFLAC
+FLAC__StreamDecoderReadStatus FLAC_read_cb(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
+FLAC__StreamDecoderSeekStatus FLAC_seek_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
+FLAC__StreamDecoderTellStatus FLAC_tell_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
+FLAC__StreamDecoderLengthStatus FLAC_length_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
+FLAC__bool FLAC_eof_cb(const FLAC__StreamDecoder *decoder, void *client_data);
+FLAC__StreamDecoderWriteStatus FLAC_write_cb(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data);
+void FLAC_metadata_cb(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
+void FLAC_error_cb(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
+
+#endif // ifndef SOUNDSOURCEFLAC_H

=== modified file 'mixxx/src/soundsourceproxy.cpp'
--- mixxx/src/soundsourceproxy.cpp	2010-10-14 04:25:11 +0000
+++ mixxx/src/soundsourceproxy.cpp	2010-11-14 02:21:19 +0000
@@ -26,6 +26,7 @@
 #ifdef __FFMPEGFILE__
 #include "soundsourceffmpeg.h"
 #endif
+#include "soundsourceflac.h"
 
 #include <QLibrary>
 #include <QMutexLocker>
@@ -117,6 +118,8 @@
 	    return new SoundSourceMp3(qFilename);
     } else if (SoundSourceOggVorbis::supportedFileExtensions().contains(extension)) {
 	    return new SoundSourceOggVorbis(qFilename);
+    } else if (SoundSourceFLAC::supportedFileExtensions().contains(extension)) {
+        return new SoundSourceFLAC(qFilename);
     } else if (m_extensionsSupportedByPlugins.contains(extension)) {
         getSoundSourceFunc getter = m_extensionsSupportedByPlugins.value(extension);
         if (getter)