src/decoders/mpg123.cpp

   1
   2 #include "mpg123.hpp"
   3
   4 #include <stdexcept>
   5 #include <iostream>
   6
   7 #include "mpg123.h"
   8
   9 namespace alure
  10 {
  11
  12 static ssize_t r_read(void *user_data, void *ptr, size_t count)
  13 {
  14     std::istream *file = reinterpret_cast<std::istream*>(user_data);
  15
  16     file->clear();
  17     file->read(reinterpret_cast<char*>(ptr), count);
  18     return file->gcount();
  19 }
  20
  21 static off_t r_lseek(void *user_data, off_t offset, int whence)
  22 {
  23     std::istream *file = reinterpret_cast<std::istream*>(user_data);
  24
  25     file->clear();
  26     if(!file->seekg(offset, std::ios::seekdir(whence)))
  27         return -1;
  28     return file->tellg();
  29 }
  30
  31
  32 class Mpg123Decoder final : public Decoder {
  33     UniquePtr<std::istream> mFile;
  34
  35     mpg123_handle *mMpg123;
  36     int mChannels;
  37     long mSampleRate;
  38
  39 public:
  40     Mpg123Decoder(UniquePtr<std::istream> file, mpg123_handle *mpg123, int chans, long srate)
  41       : mFile(std::move(file)), mMpg123(mpg123), mChannels(chans), mSampleRate(srate)
  42     { }
  43     ~Mpg123Decoder() override;
  44
  45     ALuint getFrequency() const override;
  46     ChannelConfig getChannelConfig() const override;
  47     SampleType getSampleType() const override;
  48
  49     uint64_t getLength() const override;
  50     bool seek(uint64_t pos) override;
  51
  52     std::pair<uint64_t,uint64_t> getLoopPoints() const override;
  53
  54     ALuint read(ALvoid *ptr, ALuint count) override;
  55 };
  56
  57 Mpg123Decoder::~Mpg123Decoder()
  58 {
  59     mpg123_close(mMpg123);
  60     mpg123_delete(mMpg123);
  61     mMpg123 = 0;
  62 }
  63
  64
  65 ALuint Mpg123Decoder::getFrequency() const
  66 {
  67     return mSampleRate;
  68 }
  69
  70 ChannelConfig Mpg123Decoder::getChannelConfig() const
  71 {
  72     if(mChannels == 1)
  73         return ChannelConfig::Mono;
  74     if(mChannels == 2)
  75         return ChannelConfig::Stereo;
  76     throw std::runtime_error("Unsupported sample configuration");
  77 }
  78
  79 SampleType Mpg123Decoder::getSampleType() const
  80 {
  81     return SampleType::Int16;
  82 }
  83
  84
  85 uint64_t Mpg123Decoder::getLength() const
  86 {
  87     off_t len = mpg123_length(mMpg123);
  88     return (ALuint)std::max<off_t>(len, 0);
  89 }
  90
  91 bool Mpg123Decoder::seek(uint64_t pos)
  92 {
  93     off_t newpos = mpg123_seek(mMpg123, pos, SEEK_SET);
  94     if(newpos < 0) return false;
  95     return true;
  96 }
  97
  98 std::pair<uint64_t,uint64_t> Mpg123Decoder::getLoopPoints() const
  99 {
 100     return std::make_pair(0, 0);
 101 }
 102
 103 ALuint Mpg123Decoder::read(ALvoid *ptr, ALuint count)
 104 {
 105     unsigned char *dst = reinterpret_cast<unsigned char*>(ptr);
 106     ALuint bytes = count * mChannels * 2;
 107     ALuint total = 0;
 108     while(total < bytes)
 109     {
 110         size_t got = 0;
 111         int ret = mpg123_read(mMpg123, dst+total, bytes-total, &got);
 112         if((ret != MPG123_OK && ret != MPG123_DONE) || got == 0)
 113             break;
 114
 115         total += got;
 116         if(ret == MPG123_DONE)
 117             break;
 118     }
 119     return total / mChannels / 2;
 120 }
 121
 122
 123 Mpg123DecoderFactory::Mpg123DecoderFactory()
 124   : mIsInited(false)
 125 {
 126     if(!mIsInited)
 127     {
 128         if(mpg123_init() == MPG123_OK)
 129             mIsInited = true;
 130     }
 131 }
 132
 133 Mpg123DecoderFactory::~Mpg123DecoderFactory()
 134 {
 135     if(mIsInited)
 136         mpg123_exit();
 137     mIsInited = false;
 138 }
 139
 140
 141 SharedPtr<Decoder> Mpg123DecoderFactory::createDecoder(UniquePtr<std::istream> &file)
 142 {
 143     if(!mIsInited)
 144         return nullptr;
 145
 146     mpg123_handle *mpg123 = mpg123_new(0, 0);
 147     if(mpg123)
 148     {
 149         if(mpg123_replace_reader_handle(mpg123, r_read, r_lseek, 0) == MPG123_OK &&
 150            mpg123_open_handle(mpg123, file.get()) == MPG123_OK)
 151         {
 152             int enc, channels;
 153             long srate;
 154
 155             if(mpg123_getformat(mpg123, &srate, &channels, &enc) == MPG123_OK)
 156             {
 157                 if((channels == 1 || channels == 2) && srate > 0 &&
 158                    mpg123_format_none(mpg123) == MPG123_OK &&
 159                    mpg123_format(mpg123, srate, channels, MPG123_ENC_SIGNED_16) == MPG123_OK)
 160                 {
 161                     // All OK
 162                     return MakeShared<Mpg123Decoder>(std::move(file), mpg123, channels, srate);
 163                 }
 164             }
 165             mpg123_close(mpg123);
 166         }
 167         mpg123_delete(mpg123);
 168     }
 169
 170     return nullptr;
 171 }
 172
 173 }