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     UniquePtr<std::istream> mFile;
  16
  17     FLAC__StreamDecoder *mFlacFile;
  18     ChannelConfig mChannelConfig;
  19     SampleType mSampleType;
  20     ALuint mFrequency;
  21     ALuint mFrameSize;
  22     uint64_t mSamplePos;
  23
  24     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             int shift = 8 - frame->header.bits_per_sample;
  35             ALubyte *samples = output;
  36             for(ALuint c = 0;c < frame->header.channels;c++)
  37             {
  38                 for(ALuint i = 0;i < todo;i++)
  39                     samples[i*frame->header.channels + c] = ALubyte((buffer[c][offset+i]<<shift) + 0x80);
  40             }
  41         }
  42         else if(mSampleType == SampleType::Int16)
  43         {
  44             int shift = 16 - frame->header.bits_per_sample;
  45             ALshort *samples = reinterpret_cast<ALshort*>(output);
  46             if(shift >= 0)
  47             {
  48                 for(ALuint c = 0;c < frame->header.channels;c++)
  49                 {
  50                     for(ALuint i = 0;i < todo;i++)
  51                         samples[i*frame->header.channels + c] = buffer[c][offset+i] << shift;
  52                 }
  53             }
  54             else
  55             {
  56                 shift = -shift;
  57                 for(ALuint c = 0;c < frame->header.channels;c++)
  58                 {
  59                     for(ALuint i = 0;i < todo;i++)
  60                         samples[i*frame->header.channels + c] = buffer[c][offset+i] >> shift;
  61                 }
  62             }
  63         }
  64         else
  65         {
  66             ALfloat scale = 1.0f / (float)(1<<(frame->header.bits_per_sample-1));
  67             ALfloat *samples = reinterpret_cast<ALfloat*>(output);
  68             for(ALuint c = 0;c < frame->header.channels;c++)
  69             {
  70                 for(ALuint i = 0;i < todo;i++)
  71                     samples[i*frame->header.channels + c] = (ALfloat)buffer[c][offset+i] * scale;
  72             }
  73         }
  74     }
  75
  76     static FLAC__StreamDecoderWriteStatus WriteCallback(const FLAC__StreamDecoder*, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data)
  77     {
  78         FlacDecoder *self = static_cast<FlacDecoder*>(client_data);
  79
  80         if(self->mFrequency == 0)
  81         {
  82             if(frame->header.channels == 1)
  83                 self->mChannelConfig = ChannelConfig::Mono;
  84             else if(frame->header.channels == 2)
  85                 self->mChannelConfig = ChannelConfig::Stereo;
  86             else
  87                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
  88
  89             ALuint bps = frame->header.bits_per_sample;
  90             if(bps > 16 && Context::GetCurrent().isSupported(self->mChannelConfig, SampleType::Float32))
  91             {
  92                 self->mSampleType = SampleType::Float32;
  93                 bps = 32;
  94             }
  95             else if(bps > 8)
  96             {
  97                 self->mSampleType = SampleType::Int16;
  98                 bps = 16;
  99             }
 100             else
 101             {
 102                 self->mSampleType = SampleType::UInt8;
 103                 bps = 8;
 104             }
 105
 106             self->mFrameSize = frame->header.channels * bps/8;
 107             self->mFrequency = frame->header.sample_rate;
 108         }
 109
 110         ALubyte *data = self->mOutBytes + self->mOutLen;
 111         ALuint todo = std::min<ALuint>((self->mOutMax-self->mOutLen) / self->mFrameSize,
 112                                        frame->header.blocksize);
 113         self->CopySamples(data, todo, frame, buffer, 0);
 114         self->mOutLen += self->mFrameSize * todo;
 115
 116         if(todo < frame->header.blocksize)
 117         {
 118             ALuint offset = todo;
 119             todo = frame->header.blocksize - todo;
 120
 121             ALuint blocklen = todo * self->mFrameSize;
 122             ALuint start = self->mData.size();
 123
 124             self->mData.resize(start+blocklen);
 125             data = &self->mData[start];
 126
 127             self->CopySamples(data, todo, frame, buffer, offset);
 128         }
 129
 130         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 131     }
 132     static void MetadataCallback(const FLAC__StreamDecoder*,const FLAC__StreamMetadata*,void*)
 133     {
 134     }
 135     static void ErrorCallback(const FLAC__StreamDecoder*,FLAC__StreamDecoderErrorStatus,void*)
 136     {
 137     }
 138
 139     static FLAC__StreamDecoderReadStatus ReadCallback(const FLAC__StreamDecoder*, FLAC__byte buffer[], size_t *bytes, void *client_data)
 140     {
 141         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 142         stream->clear();
 143
 144         if(*bytes <= 0)
 145             return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 146
 147         stream->read(reinterpret_cast<char*>(buffer), *bytes);
 148         *bytes = stream->gcount();
 149         if(*bytes == 0 && stream->eof())
 150             return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 151
 152         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 153     }
 154     static FLAC__StreamDecoderSeekStatus SeekCallback(const FLAC__StreamDecoder*, FLAC__uint64 absolute_byte_offset, void *client_data)
 155     {
 156         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 157         stream->clear();
 158
 159         if(!stream->seekg(absolute_byte_offset))
 160             return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 161         return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
 162     }
 163     static FLAC__StreamDecoderTellStatus TellCallback(const FLAC__StreamDecoder*, FLAC__uint64 *absolute_byte_offset, void *client_data)
 164     {
 165         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 166         stream->clear();
 167
 168         *absolute_byte_offset = stream->tellg();
 169         return FLAC__STREAM_DECODER_TELL_STATUS_OK;
 170     }
 171     static FLAC__StreamDecoderLengthStatus LengthCallback(const FLAC__StreamDecoder*, FLAC__uint64 *stream_length, void *client_data)
 172     {
 173         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 174         stream->clear();
 175
 176         std::streampos pos = stream->tellg();
 177         if(stream->seekg(0, std::ios_base::end))
 178         {
 179             *stream_length = stream->tellg();
 180             stream->seekg(pos);
 181         }
 182
 183         if(!stream->good())
 184             return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
 185         return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
 186     }
 187     static FLAC__bool EofCallback(const FLAC__StreamDecoder*, void *client_data)
 188     {
 189         std::istream *stream = static_cast<FlacDecoder*>(client_data)->mFile.get();
 190         return stream->eof() ? true : false;
 191     }
 192
 193 public:
 194     FlacDecoder()
 195       : mFlacFile(nullptr), mChannelConfig(ChannelConfig::Mono), mSampleType(SampleType::Int16)
 196       , mFrequency(0), mFrameSize(0), mSamplePos(0), mOutBytes(nullptr), mOutMax(0), mOutLen(0)
 197     { }
 198     ~FlacDecoder() override final;
 199
 200     bool open(UniquePtr<std::istream> &file);
 201
 202     ALuint getFrequency() const override final;
 203     ChannelConfig getChannelConfig() const override final;
 204     SampleType getSampleType() const override final;
 205
 206     uint64_t getLength() const override final;
 207     uint64_t getPosition() const override final;
 208     bool seek(uint64_t pos) override final;
 209
 210     std::pair<uint64_t,uint64_t> getLoopPoints() const override final;
 211
 212     ALuint read(ALvoid *ptr, ALuint count) override final;
 213 };
 214
 215 FlacDecoder::~FlacDecoder()
 216 {
 217     if(mFlacFile)
 218     {
 219         FLAC__stream_decoder_finish(mFlacFile);
 220         FLAC__stream_decoder_delete(mFlacFile);
 221         mFlacFile = nullptr;
 222     }
 223 }
 224
 225
 226 bool FlacDecoder::open(UniquePtr<std::istream> &file)
 227 {
 228     mFlacFile = FLAC__stream_decoder_new();
 229     if(mFlacFile)
 230     {
 231         mFile = std::move(file);
 232         if(FLAC__stream_decoder_init_stream(mFlacFile, ReadCallback, SeekCallback, TellCallback, LengthCallback, EofCallback, WriteCallback, MetadataCallback, ErrorCallback, this) == FLAC__STREAM_DECODER_INIT_STATUS_OK)
 233         {
 234             while(mData.empty())
 235             {
 236                 if(FLAC__stream_decoder_process_single(mFlacFile) == false ||
 237                    FLAC__stream_decoder_get_state(mFlacFile) == FLAC__STREAM_DECODER_END_OF_STREAM)
 238                     break;
 239             }
 240             if(!mData.empty())
 241                 return true;
 242
 243             FLAC__stream_decoder_finish(mFlacFile);
 244         }
 245         FLAC__stream_decoder_delete(mFlacFile);
 246         mFlacFile = nullptr;
 247
 248         file = std::move(mFile);
 249     }
 250
 251     return false;
 252 }
 253
 254
 255 ALuint FlacDecoder::getFrequency() const
 256 {
 257     return mFrequency;
 258 }
 259
 260 ChannelConfig FlacDecoder::getChannelConfig() const
 261 {
 262     return mChannelConfig;
 263 }
 264
 265 SampleType FlacDecoder::getSampleType() const
 266 {
 267     return mSampleType;
 268 }
 269
 270
 271 uint64_t FlacDecoder::getLength() const
 272 {
 273     return FLAC__stream_decoder_get_total_samples(mFlacFile);
 274 }
 275
 276 uint64_t FlacDecoder::getPosition() const
 277 {
 278     return mSamplePos;
 279 }
 280
 281 bool FlacDecoder::seek(uint64_t pos)
 282 {
 283     if(!FLAC__stream_decoder_seek_absolute(mFlacFile, pos))
 284         return false;
 285     mSamplePos = pos;
 286     return true;
 287 }
 288
 289 std::pair<uint64_t,uint64_t> FlacDecoder::getLoopPoints() const
 290 {
 291     return std::make_pair(0, 0);
 292 }
 293
 294 ALuint FlacDecoder::read(ALvoid *ptr, ALuint count)
 295 {
 296     mOutBytes = reinterpret_cast<ALubyte*>(ptr);
 297     mOutLen = 0;
 298     mOutMax = count * mFrameSize;
 299
 300     if(mData.size() > 0)
 301     {
 302         size_t rem = std::min(mData.size(), (size_t)mOutMax);
 303         memcpy(ptr, &mData[0], rem);
 304         mOutLen += rem;
 305         mData.erase(mData.begin(), mData.begin()+rem);
 306     }
 307
 308     while(mOutLen < mOutMax)
 309     {
 310         if(FLAC__stream_decoder_process_single(mFlacFile) == false ||
 311            FLAC__stream_decoder_get_state(mFlacFile) == FLAC__STREAM_DECODER_END_OF_STREAM)
 312             break;
 313     }
 314     ALuint ret = mOutLen / mFrameSize;
 315
 316     mSamplePos += ret;
 317
 318     return ret;
 319 }
 320
 321
 322 SharedPtr<Decoder> FlacDecoderFactory::createDecoder(UniquePtr<std::istream> &file)
 323 {
 324     auto decoder = MakeShared<FlacDecoder>();
 325     if(!decoder->open(file)) decoder.reset();
 326     return decoder;
 327 }
 328
 329 }