src/decoders/flac.cpp

   1
   2 #include "flac.hpp"
   3
   4 #include <stdexcept>
   5 #include <iostream>
   6 #include <cstring>
   7
   8 #include "FLAC/all.h"
   9
  10
  11 namespace alure
  12 {
  13
  14 class FlacDecoder : public Decoder {
  15     SharedPtr<std::istream> mFile;
  16
  17     FLAC__StreamDecoder *mFlacFile;
  18     SampleConfig mSampleConfig;
  19     SampleType mSampleType;
  20     ALuint mFrequency;
  21     ALuint mFrameSize;
  22     uint64_t mSamplePos;
  23
  24     std::vector<ALubyte> mData;
  25
  26     ALubyte *mOutBytes;
  27     ALuint mOutMax;
  28     ALuint mOutLen;
  29
  30     void CopySamples(ALubyte *output, ALuint todo, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], ALuint offset)
  31     {
  32         if(mSampleType == SampleType_UInt8)
  33         {
  34             ALubyte *samples = output;
  35             for(ALuint i = 0;i < todo;i++)
  36             {
  37                 for(ALuint c = 0;c < frame->header.channels;c++)
  38                     *(samples++) = ALubyte(buffer[c][offset+i] + 0x80);
  39             }
  40         }
  41         else
  42         {
  43             int shift = frame->header.bits_per_sample - 16;
  44             ALshort *samples = reinterpret_cast<ALshort*>(output);
  45             for(ALuint i = 0;i < todo;i++)
  46             {
  47                 for(ALuint c = 0;c < frame->header.channels;c++)
  48                     *(samples++) = buffer[c][offset+i] >> shift;
  49             }
  50         }
  51     }
  52
  53     static FLAC__StreamDecoderWriteStatus WriteCallback(const FLAC__StreamDecoder*, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data)
  54     {
  55         FlacDecoder *self = static_cast<FlacDecoder*>(client_data);
  56
  57         if(self->mFrequency == 0)
  58         {
  59             ALuint bps = frame->header.bits_per_sample;
  60             if(bps == 8)
  61                 self->mSampleType = SampleType_UInt8;
  62             else
  63             {
  64                 self->mSampleType = SampleType_Int16;
  65                 bps = 16;
  66             }
  67
  68             if(frame->header.channels == 1)
  69                 self->mSampleConfig = SampleConfig_Mono;
  70             else if(frame->header.channels == 2)
  71                 self->mSampleConfig = SampleConfig_Stereo;
  72             else
  73                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
  74
  75             self->mFrameSize = frame->header.channels * bps/8;
  76             self->mFrequency = frame->header.sample_rate;
  77         }
  78
  79         ALubyte *data = self->mOutBytes + self->mOutLen;
  80         ALuint todo = std::min<ALuint>((self->mOutMax-self->mOutLen) / self->mFrameSize,
  81                                        frame->header.blocksize);
  82         self->CopySamples(data, todo, frame, buffer, 0);
  83         self->mOutLen += self->mFrameSize * todo;
  84
  85         if(todo < frame->header.blocksize)
  86         {
  87             ALuint offset = todo;
  88             todo = frame->header.blocksize - todo;
  89
  90             ALuint blocklen = todo * self->mFrameSize;
  91             ALuint start = self->mData.size();
  92
  93             self->mData.resize(start+blocklen);
  94             data = &self->mData[start];
  95
  96             self->CopySamples(data, todo, frame, buffer, offset);
  97         }
  98
  99         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 100     }
 101     static void MetadataCallback(const FLAC__StreamDecoder*,const FLAC__StreamMetadata*,void*)
 102     {
 103     }
 104     static void ErrorCallback(const FLAC__StreamDecoder*,FLAC__StreamDecoderErrorStatus,void*)
 105     {
 106     }
 107
 108     static FLAC__StreamDecoderReadStatus ReadCallback(const FLAC__StreamDecoder*, FLAC__byte buffer[], size_t *bytes, void *client_data)
 109     {
 110         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 111         stream->clear();
 112
 113         if(*bytes <= 0)
 114             return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 115
 116         stream->read(reinterpret_cast<char*>(buffer), *bytes);
 117         *bytes = stream->gcount();
 118         if(*bytes == 0 && stream->eof())
 119             return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 120
 121         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 122     }
 123     static FLAC__StreamDecoderSeekStatus SeekCallback(const FLAC__StreamDecoder*, FLAC__uint64 absolute_byte_offset, void *client_data)
 124     {
 125         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 126         stream->clear();
 127
 128         if(!stream->seekg(absolute_byte_offset))
 129             return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 130         return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
 131     }
 132     static FLAC__StreamDecoderTellStatus TellCallback(const FLAC__StreamDecoder*, FLAC__uint64 *absolute_byte_offset, void *client_data)
 133     {
 134         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 135         stream->clear();
 136
 137         *absolute_byte_offset = stream->tellg();
 138         return FLAC__STREAM_DECODER_TELL_STATUS_OK;
 139     }
 140     static FLAC__StreamDecoderLengthStatus LengthCallback(const FLAC__StreamDecoder*, FLAC__uint64 *stream_length, void *client_data)
 141     {
 142         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 143         stream->clear();
 144
 145         std::streampos pos = stream->tellg();
 146         if(stream->seekg(0, std::ios_base::end))
 147         {
 148             *stream_length = stream->tellg();
 149             stream->seekg(pos);
 150         }
 151
 152         if(!stream->good())
 153             return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
 154         return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
 155     }
 156     static FLAC__bool EofCallback(const FLAC__StreamDecoder*, void *client_data)
 157     {
 158         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 159         return stream->eof() ? true : false;
 160     }
 161
 162 public:
 163     FlacDecoder(SharedPtr<std::istream> file)
 164       : mFile(file), mFlacFile(nullptr), mSampleConfig(SampleConfig_Mono), mSampleType(SampleType_Int16), mFrequency(0),
 165         mFrameSize(0), mSamplePos(0), mOutBytes(nullptr), mOutMax(0), mOutLen(0)
 166     { }
 167     virtual ~FlacDecoder();
 168
 169     bool open();
 170
 171     virtual ALuint getFrequency() final;
 172     virtual SampleConfig getSampleConfig() final;
 173     virtual SampleType getSampleType() final;
 174
 175     virtual uint64_t getLength() final;
 176     virtual uint64_t getPosition() final;
 177     virtual bool seek(uint64_t pos) final;
 178
 179     virtual ALuint read(ALvoid *ptr, ALuint count) final;
 180 };
 181
 182 FlacDecoder::~FlacDecoder()
 183 {
 184     if(mFlacFile)
 185     {
 186         FLAC__stream_decoder_finish(mFlacFile);
 187         FLAC__stream_decoder_delete(mFlacFile);
 188         mFlacFile = nullptr;
 189     }
 190 }
 191
 192
 193 bool FlacDecoder::open()
 194 {
 195     mFlacFile = FLAC__stream_decoder_new();
 196     if(mFlacFile)
 197     {
 198         if(FLAC__stream_decoder_init_stream(mFlacFile, ReadCallback, SeekCallback, TellCallback, LengthCallback, EofCallback, WriteCallback, MetadataCallback, ErrorCallback, this) == FLAC__STREAM_DECODER_INIT_STATUS_OK)
 199         {
 200             while(mData.size() == 0)
 201             {
 202                 if(FLAC__stream_decoder_process_single(mFlacFile) == false ||
 203                    FLAC__stream_decoder_get_state(mFlacFile) == FLAC__STREAM_DECODER_END_OF_STREAM)
 204                     break;
 205             }
 206             if(mData.size() > 0)
 207                 return true;
 208
 209             FLAC__stream_decoder_finish(mFlacFile);
 210         }
 211         FLAC__stream_decoder_delete(mFlacFile);
 212         mFlacFile = nullptr;
 213     }
 214
 215     return false;
 216 }
 217
 218
 219 ALuint FlacDecoder::getFrequency()
 220 {
 221     return mFrequency;
 222 }
 223
 224 SampleConfig FlacDecoder::getSampleConfig()
 225 {
 226     return mSampleConfig;
 227 }
 228
 229 SampleType FlacDecoder::getSampleType()
 230 {
 231     return mSampleType;
 232 }
 233
 234
 235 uint64_t FlacDecoder::getLength()
 236 {
 237     return FLAC__stream_decoder_get_total_samples(mFlacFile);
 238 }
 239
 240 uint64_t FlacDecoder::getPosition()
 241 {
 242     return mSamplePos;
 243 }
 244
 245 bool FlacDecoder::seek(uint64_t pos)
 246 {
 247     if(!FLAC__stream_decoder_seek_absolute(mFlacFile, pos))
 248         return false;
 249     mSamplePos = pos;
 250     return true;
 251 }
 252
 253 ALuint FlacDecoder::read(ALvoid *ptr, ALuint count)
 254 {
 255     mOutBytes = reinterpret_cast<ALubyte*>(ptr);
 256     mOutLen = 0;
 257     mOutMax = count * mFrameSize;
 258
 259     if(mData.size() > 0)
 260     {
 261         size_t rem = std::min(mData.size(), (size_t)mOutMax);
 262         memcpy(ptr, &mData[0], rem);
 263         mOutLen += rem;
 264         mData.erase(mData.begin(), mData.begin()+rem);
 265     }
 266
 267     while(mOutLen < mOutMax)
 268     {
 269         if(FLAC__stream_decoder_process_single(mFlacFile) == false ||
 270            FLAC__stream_decoder_get_state(mFlacFile) == FLAC__STREAM_DECODER_END_OF_STREAM)
 271             break;
 272     }
 273     ALuint ret = mOutLen / mFrameSize;
 274
 275     mSamplePos += ret;
 276
 277     return ret;
 278 }
 279
 280
 281 SharedPtr<Decoder> FlacDecoderFactory::createDecoder(SharedPtr<std::istream> file)
 282 {
 283     SharedPtr<FlacDecoder> decoder(new FlacDecoder(file));
 284     if(!decoder->open()) decoder.reset();
 285     return decoder;
 286 }
 287
 288 }