src/decoders/opusfile.cpp

   1
   2 #include "opusfile.hpp"
   3
   4 #include <stdexcept>
   5 #include <iostream>
   6 #include <limits>
   7
   8 #include "buffer.h"
   9
  10 #include "opusfile.h"
  11
  12 namespace alure
  13 {
  14
  15 static int read(void *user_data, unsigned char *ptr, int size)
  16 {
  17     std::istream *stream = static_cast<std::istream*>(user_data);
  18     stream->clear();
  19
  20     if(size < 0 || !stream->read(reinterpret_cast<char*>(ptr), size))
  21         return -1;
  22     return stream->gcount();
  23 }
  24
  25 static int seek(void *user_data, opus_int64 offset, int whence)
  26 {
  27     std::istream *stream = static_cast<std::istream*>(user_data);
  28     stream->clear();
  29
  30     if(whence == SEEK_CUR)
  31         stream->seekg(offset, std::ios_base::cur);
  32     else if(whence == SEEK_SET)
  33         stream->seekg(offset, std::ios_base::beg);
  34     else if(whence == SEEK_END)
  35         stream->seekg(offset, std::ios_base::end);
  36     else
  37         return -1;
  38
  39     return stream->good() ? 0 : -1;
  40 }
  41
  42 static opus_int64 tell(void *user_data)
  43 {
  44     std::istream *stream = static_cast<std::istream*>(user_data);
  45     stream->clear();
  46     return stream->tellg();
  47 }
  48
  49
  50 class OpusFileDecoder : public Decoder {
  51     UniquePtr<std::istream> mFile;
  52
  53     OggOpusFile *mOggFile;
  54     int mOggBitstream;
  55
  56     ChannelConfig mChannelConfig;
  57
  58 public:
  59     OpusFileDecoder(UniquePtr<std::istream> file, OggOpusFile *oggfile, ChannelConfig sconfig)
  60       : mFile(std::move(file)), mOggFile(oggfile), mOggBitstream(0), mChannelConfig(sconfig)
  61     { }
  62     ~OpusFileDecoder() override final;
  63
  64     ALuint getFrequency() const override final;
  65     ChannelConfig getChannelConfig() const override final;
  66     SampleType getSampleType() const override final;
  67
  68     uint64_t getLength() const override final;
  69     uint64_t getPosition() const override final;
  70     bool seek(uint64_t pos) override final;
  71
  72     std::pair<uint64_t,uint64_t> getLoopPoints() const override final;
  73
  74     ALuint read(ALvoid *ptr, ALuint count) override final;
  75 };
  76
  77 OpusFileDecoder::~OpusFileDecoder()
  78 {
  79     op_free(mOggFile);
  80 }
  81
  82
  83 ALuint OpusFileDecoder::getFrequency() const
  84 {
  85     // libopusfile always decodes to 48khz.
  86     return 48000;
  87 }
  88
  89 ChannelConfig OpusFileDecoder::getChannelConfig() const
  90 {
  91     return mChannelConfig;
  92 }
  93
  94 SampleType OpusFileDecoder::getSampleType() const
  95 {
  96     return SampleType::Int16;
  97 }
  98
  99
 100 uint64_t OpusFileDecoder::getLength() const
 101 {
 102     ogg_int64_t len = op_pcm_total(mOggFile, -1);
 103     return std::max<ogg_int64_t>(len, 0);
 104 }
 105
 106 uint64_t OpusFileDecoder::getPosition() const
 107 {
 108     ogg_int64_t pos = op_pcm_tell(mOggFile);
 109     return std::max<ogg_int64_t>(pos, 0);
 110 }
 111
 112 bool OpusFileDecoder::seek(uint64_t pos)
 113 {
 114     return op_pcm_seek(mOggFile, pos) == 0;
 115 }
 116
 117 std::pair<uint64_t,uint64_t> OpusFileDecoder::getLoopPoints() const
 118 {
 119     return std::make_pair(0, std::numeric_limits<uint64_t>::max());
 120 }
 121
 122 ALuint OpusFileDecoder::read(ALvoid *ptr, ALuint count)
 123 {
 124     ALuint total = 0;
 125     opus_int16 *samples = (opus_int16*)ptr;
 126     int num_chans = FramesToBytes(1, mChannelConfig, SampleType::UInt8);
 127     while(total < count)
 128     {
 129         if(num_chans != op_head(mOggFile, -1)->channel_count)
 130             break;
 131         int len = (count-total) * num_chans;
 132
 133         long got = op_read(mOggFile, samples, len, &mOggBitstream);
 134         if(got <= 0) break;
 135
 136         samples += got*num_chans;
 137         total += got;
 138     }
 139
 140     // 1, 2, and 4 channel files decode into the same channel order as
 141     // OpenAL, however 6 (5.1), 7 (6.1), and 8 (7.1) channel files need to be
 142     // re-ordered.
 143     if(mChannelConfig == ChannelConfig::X51)
 144     {
 145         samples = (opus_int16*)ptr;
 146         for(ALuint i = 0;i < total;++i)
 147         {
 148             // OpenAL : FL, FR, FC, LFE, RL, RR
 149             // Opus   : FL, FC, FR,  RL, RR, LFE
 150             std::swap(samples[i*6 + 1], samples[i*6 + 2]);
 151             std::swap(samples[i*6 + 3], samples[i*6 + 5]);
 152             std::swap(samples[i*6 + 4], samples[i*6 + 5]);
 153         }
 154     }
 155     else if(mChannelConfig == ChannelConfig::X61)
 156     {
 157         samples = (opus_int16*)ptr;
 158         for(ALuint i = 0;i < total;++i)
 159         {
 160             // OpenAL : FL, FR, FC, LFE, RC, SL, SR
 161             // Opus   : FL, FC, FR,  SL, SR, RC, LFE
 162             std::swap(samples[i*7 + 1], samples[i*7 + 2]);
 163             std::swap(samples[i*7 + 3], samples[i*7 + 6]);
 164             std::swap(samples[i*7 + 4], samples[i*7 + 5]);
 165             std::swap(samples[i*7 + 5], samples[i*7 + 6]);
 166         }
 167     }
 168     else if(mChannelConfig == ChannelConfig::X71)
 169     {
 170         samples = (opus_int16*)ptr;
 171         for(ALuint i = 0;i < total;++i)
 172         {
 173             // OpenAL : FL, FR, FC, LFE, RL, RR, SL, SR
 174             // Opus   : FL, FC, FR,  SL, SR, RL, RR, LFE
 175             std::swap(samples[i*8 + 1], samples[i*8 + 2]);
 176             std::swap(samples[i*8 + 3], samples[i*8 + 7]);
 177             std::swap(samples[i*8 + 4], samples[i*8 + 5]);
 178             std::swap(samples[i*8 + 5], samples[i*8 + 6]);
 179             std::swap(samples[i*8 + 6], samples[i*8 + 7]);
 180         }
 181     }
 182
 183     return total;
 184 }
 185
 186
 187 SharedPtr<Decoder> OpusFileDecoderFactory::createDecoder(UniquePtr<std::istream> &file)
 188 {
 189     static const OpusFileCallbacks streamIO = {
 190         read, seek, tell, nullptr
 191     };
 192
 193     OggOpusFile *oggfile = op_open_callbacks(file.get(), &streamIO, nullptr, 0, nullptr);
 194     if(!oggfile) return nullptr;
 195
 196     int num_chans = op_head(oggfile, -1)->channel_count;
 197     ChannelConfig channels = ChannelConfig::Mono;
 198     if(num_chans == 1)
 199         channels = ChannelConfig::Mono;
 200     else if(num_chans == 2)
 201         channels = ChannelConfig::Stereo;
 202     else if(num_chans == 4)
 203         channels = ChannelConfig::Quad;
 204     else if(num_chans == 6)
 205         channels = ChannelConfig::X51;
 206     else if(num_chans == 7)
 207         channels = ChannelConfig::X61;
 208     else if(num_chans == 8)
 209         channels = ChannelConfig::X71;
 210     else
 211     {
 212         op_free(oggfile);
 213         return nullptr;
 214     }
 215
 216     return MakeShared<OpusFileDecoder>(std::move(file), oggfile, channels);
 217 }
 218
 219 }