alc/converter.cpp

   1
   2 #include "config.h"
   3
   4 #include "converter.h"
   5
   6 #include <algorithm>
   7 #include <cstdint>
   8 #include <iterator>
   9
  10 #include "AL/al.h"
  11
  12 #include "albyte.h"
  13 #include "alu.h"
  14 #include "fpu_ctrl.h"
  15 #include "mixer/defs.h"
  16
  17 struct CTag;
  18 struct CopyTag;
  19
  20
  21 namespace {
  22
  23 /* Base template left undefined. Should be marked =delete, but Clang 3.8.1
  24  * chokes on that given the inline specializations.
  25  */
  26 template<DevFmtType T>
  27 inline float LoadSample(typename DevFmtTypeTraits<T>::Type val) noexcept;
  28
  29 template<> inline float LoadSample<DevFmtByte>(DevFmtTypeTraits<DevFmtByte>::Type val) noexcept
  30 { return val * (1.0f/128.0f); }
  31 template<> inline float LoadSample<DevFmtShort>(DevFmtTypeTraits<DevFmtShort>::Type val) noexcept
  32 { return val * (1.0f/32768.0f); }
  33 template<> inline float LoadSample<DevFmtInt>(DevFmtTypeTraits<DevFmtInt>::Type val) noexcept
  34 { return static_cast<float>(val) * (1.0f/2147483648.0f); }
  35 template<> inline float LoadSample<DevFmtFloat>(DevFmtTypeTraits<DevFmtFloat>::Type val) noexcept
  36 { return val; }
  37
  38 template<> inline float LoadSample<DevFmtUByte>(DevFmtTypeTraits<DevFmtUByte>::Type val) noexcept
  39 { return LoadSample<DevFmtByte>(static_cast<ALbyte>(val - 128)); }
  40 template<> inline float LoadSample<DevFmtUShort>(DevFmtTypeTraits<DevFmtUShort>::Type val) noexcept
  41 { return LoadSample<DevFmtShort>(static_cast<ALshort>(val - 32768)); }
  42 template<> inline float LoadSample<DevFmtUInt>(DevFmtTypeTraits<DevFmtUInt>::Type val) noexcept
  43 { return LoadSample<DevFmtInt>(static_cast<ALint>(val - 2147483648u)); }
  44
  45
  46 template<DevFmtType T>
  47 inline void LoadSampleArray(float *RESTRICT dst, const void *src, const size_t srcstep,
  48     const size_t samples) noexcept
  49 {
  50     using SampleType = typename DevFmtTypeTraits<T>::Type;
  51
  52     const SampleType *ssrc = static_cast<const SampleType*>(src);
  53     for(size_t i{0u};i < samples;i++)
  54         dst[i] = LoadSample<T>(ssrc[i*srcstep]);
  55 }
  56
  57 void LoadSamples(float *dst, const void *src, const size_t srcstep, const DevFmtType srctype,
  58     const size_t samples) noexcept
  59 {
  60 #define HANDLE_FMT(T)                                                         \
  61     case T: LoadSampleArray<T>(dst, src, srcstep, samples); break
  62     switch(srctype)
  63     {
  64         HANDLE_FMT(DevFmtByte);
  65         HANDLE_FMT(DevFmtUByte);
  66         HANDLE_FMT(DevFmtShort);
  67         HANDLE_FMT(DevFmtUShort);
  68         HANDLE_FMT(DevFmtInt);
  69         HANDLE_FMT(DevFmtUInt);
  70         HANDLE_FMT(DevFmtFloat);
  71     }
  72 #undef HANDLE_FMT
  73 }
  74
  75
  76 template<DevFmtType T>
  77 inline typename DevFmtTypeTraits<T>::Type StoreSample(float) noexcept;
  78
  79 template<> inline ALfloat StoreSample<DevFmtFloat>(float val) noexcept
  80 { return val; }
  81 template<> inline ALint StoreSample<DevFmtInt>(float val) noexcept
  82 { return fastf2i(clampf(val*2147483648.0f, -2147483648.0f, 2147483520.0f)); }
  83 template<> inline ALshort StoreSample<DevFmtShort>(float val) noexcept
  84 { return static_cast<ALshort>(fastf2i(clampf(val*32768.0f, -32768.0f, 32767.0f))); }
  85 template<> inline ALbyte StoreSample<DevFmtByte>(float val) noexcept
  86 { return static_cast<ALbyte>(fastf2i(clampf(val*128.0f, -128.0f, 127.0f))); }
  87
  88 /* Define unsigned output variations. */
  89 template<> inline ALuint StoreSample<DevFmtUInt>(float val) noexcept
  90 { return static_cast<ALuint>(StoreSample<DevFmtInt>(val)) + 2147483648u; }
  91 template<> inline ALushort StoreSample<DevFmtUShort>(float val) noexcept
  92 { return static_cast<ALushort>(StoreSample<DevFmtShort>(val) + 32768); }
  93 template<> inline ALubyte StoreSample<DevFmtUByte>(float val) noexcept
  94 { return static_cast<ALubyte>(StoreSample<DevFmtByte>(val) + 128); }
  95
  96 template<DevFmtType T>
  97 inline void StoreSampleArray(void *dst, const float *RESTRICT src, const size_t dststep,
  98     const size_t samples) noexcept
  99 {
 100     using SampleType = typename DevFmtTypeTraits<T>::Type;
 101
 102     SampleType *sdst = static_cast<SampleType*>(dst);
 103     for(size_t i{0u};i < samples;i++)
 104         sdst[i*dststep] = StoreSample<T>(src[i]);
 105 }
 106
 107
 108 void StoreSamples(void *dst, const float *src, const size_t dststep, const DevFmtType dsttype,
 109     const size_t samples) noexcept
 110 {
 111 #define HANDLE_FMT(T)                                                         \
 112     case T: StoreSampleArray<T>(dst, src, dststep, samples); break
 113     switch(dsttype)
 114     {
 115         HANDLE_FMT(DevFmtByte);
 116         HANDLE_FMT(DevFmtUByte);
 117         HANDLE_FMT(DevFmtShort);
 118         HANDLE_FMT(DevFmtUShort);
 119         HANDLE_FMT(DevFmtInt);
 120         HANDLE_FMT(DevFmtUInt);
 121         HANDLE_FMT(DevFmtFloat);
 122     }
 123 #undef HANDLE_FMT
 124 }
 125
 126
 127 template<DevFmtType T>
 128 void Mono2Stereo(float *RESTRICT dst, const void *src, const size_t frames) noexcept
 129 {
 130     using SampleType = typename DevFmtTypeTraits<T>::Type;
 131
 132     const SampleType *ssrc = static_cast<const SampleType*>(src);
 133     for(size_t i{0u};i < frames;i++)
 134         dst[i*2 + 1] = dst[i*2 + 0] = LoadSample<T>(ssrc[i]) * 0.707106781187f;
 135 }
 136
 137 template<DevFmtType T>
 138 void Multi2Mono(ALuint chanmask, const size_t step, const float scale, float *RESTRICT dst,
 139     const void *src, const size_t frames) noexcept
 140 {
 141     using SampleType = typename DevFmtTypeTraits<T>::Type;
 142
 143     const SampleType *ssrc = static_cast<const SampleType*>(src);
 144     std::fill_n(dst, frames, 0.0f);
 145     for(size_t c{0};chanmask;++c)
 146     {
 147         if LIKELY((chanmask&1))
 148         {
 149             for(size_t i{0u};i < frames;i++)
 150                 dst[i] += LoadSample<T>(ssrc[i*step + c]);
 151         }
 152         chanmask >>= 1;
 153     }
 154     for(size_t i{0u};i < frames;i++)
 155         dst[i] *= scale;
 156 }
 157
 158 } // namespace
 159
 160 SampleConverterPtr CreateSampleConverter(DevFmtType srcType, DevFmtType dstType, size_t numchans,
 161     ALuint srcRate, ALuint dstRate, Resampler resampler)
 162 {
 163     if(numchans < 1 || srcRate < 1 || dstRate < 1)
 164         return nullptr;
 165
 166     SampleConverterPtr converter{new(FamCount(numchans)) SampleConverter{numchans}};
 167     converter->mSrcType = srcType;
 168     converter->mDstType = dstType;
 169     converter->mSrcTypeSize = BytesFromDevFmt(srcType);
 170     converter->mDstTypeSize = BytesFromDevFmt(dstType);
 171
 172     converter->mSrcPrepCount = 0;
 173     converter->mFracOffset = 0;
 174
 175     /* Have to set the mixer FPU mode since that's what the resampler code expects. */
 176     FPUCtl mixer_mode{};
 177     auto step = static_cast<ALuint>(
 178         mind(srcRate*double{FRACTIONONE}/dstRate + 0.5, MAX_PITCH*FRACTIONONE));
 179     converter->mIncrement = maxu(step, 1);
 180     if(converter->mIncrement == FRACTIONONE)
 181         converter->mResample = Resample_<CopyTag,CTag>;
 182     else
 183         converter->mResample = PrepareResampler(resampler, converter->mIncrement,
 184             &converter->mState);
 185
 186     return converter;
 187 }
 188
 189 ALuint SampleConverter::availableOut(ALuint srcframes) const
 190 {
 191     int prepcount{mSrcPrepCount};
 192     if(prepcount < 0)
 193     {
 194         /* Negative prepcount means we need to skip that many input samples. */
 195         if(static_cast<ALuint>(-prepcount) >= srcframes)
 196             return 0;
 197         srcframes -= static_cast<ALuint>(-prepcount);
 198         prepcount = 0;
 199     }
 200
 201     if(srcframes < 1)
 202     {
 203         /* No output samples if there's no input samples. */
 204         return 0;
 205     }
 206
 207     if(prepcount < MAX_RESAMPLER_PADDING
 208         && static_cast<ALuint>(MAX_RESAMPLER_PADDING - prepcount) >= srcframes)
 209     {
 210         /* Not enough input samples to generate an output sample. */
 211         return 0;
 212     }
 213
 214     auto DataSize64 = static_cast<uint64_t>(prepcount);
 215     DataSize64 += srcframes;
 216     DataSize64 -= MAX_RESAMPLER_PADDING;
 217     DataSize64 <<= FRACTIONBITS;
 218     DataSize64 -= mFracOffset;
 219
 220     /* If we have a full prep, we can generate at least one sample. */
 221     return static_cast<ALuint>(clampu64((DataSize64 + mIncrement-1)/mIncrement, 1, BUFFERSIZE));
 222 }
 223
 224 ALuint SampleConverter::convert(const void **src, ALuint *srcframes, void *dst, ALuint dstframes)
 225 {
 226     const ALuint SrcFrameSize{static_cast<ALuint>(mChan.size()) * mSrcTypeSize};
 227     const ALuint DstFrameSize{static_cast<ALuint>(mChan.size()) * mDstTypeSize};
 228     const ALuint increment{mIncrement};
 229     auto SamplesIn = static_cast<const al::byte*>(*src);
 230     ALuint NumSrcSamples{*srcframes};
 231
 232     FPUCtl mixer_mode{};
 233     ALuint pos{0};
 234     while(pos < dstframes && NumSrcSamples > 0)
 235     {
 236         int prepcount{mSrcPrepCount};
 237         if(prepcount < 0)
 238         {
 239             /* Negative prepcount means we need to skip that many input samples. */
 240             if(static_cast<ALuint>(-prepcount) >= NumSrcSamples)
 241             {
 242                 mSrcPrepCount = static_cast<int>(NumSrcSamples) + prepcount;
 243                 NumSrcSamples = 0;
 244                 break;
 245             }
 246             SamplesIn += SrcFrameSize*static_cast<ALuint>(-prepcount);
 247             NumSrcSamples -= static_cast<ALuint>(-prepcount);
 248             mSrcPrepCount = 0;
 249             continue;
 250         }
 251         ALuint toread{minu(NumSrcSamples, BUFFERSIZE - MAX_RESAMPLER_PADDING)};
 252
 253         if(prepcount < MAX_RESAMPLER_PADDING
 254             && static_cast<ALuint>(MAX_RESAMPLER_PADDING - prepcount) >= toread)
 255         {
 256             /* Not enough input samples to generate an output sample. Store
 257              * what we're given for later.
 258              */
 259             for(size_t chan{0u};chan < mChan.size();chan++)
 260                 LoadSamples(&mChan[chan].PrevSamples[prepcount], SamplesIn + mSrcTypeSize*chan,
 261                     mChan.size(), mSrcType, toread);
 262
 263             mSrcPrepCount = prepcount + static_cast<int>(toread);
 264             NumSrcSamples = 0;
 265             break;
 266         }
 267
 268         float *RESTRICT SrcData{mSrcSamples};
 269         float *RESTRICT DstData{mDstSamples};
 270         ALuint DataPosFrac{mFracOffset};
 271         auto DataSize64 = static_cast<uint64_t>(prepcount);
 272         DataSize64 += toread;
 273         DataSize64 -= MAX_RESAMPLER_PADDING;
 274         DataSize64 <<= FRACTIONBITS;
 275         DataSize64 -= DataPosFrac;
 276
 277         /* If we have a full prep, we can generate at least one sample. */
 278         auto DstSize = static_cast<ALuint>(
 279             clampu64((DataSize64 + increment-1)/increment, 1, BUFFERSIZE));
 280         DstSize = minu(DstSize, dstframes-pos);
 281
 282         for(size_t chan{0u};chan < mChan.size();chan++)
 283         {
 284             const al::byte *SrcSamples{SamplesIn + mSrcTypeSize*chan};
 285             al::byte *DstSamples = static_cast<al::byte*>(dst) + mDstTypeSize*chan;
 286
 287             /* Load the previous samples into the source data first, then the
 288              * new samples from the input buffer.
 289              */
 290             std::copy_n(mChan[chan].PrevSamples, prepcount, SrcData);
 291             LoadSamples(SrcData + prepcount, SrcSamples, mChan.size(), mSrcType, toread);
 292
 293             /* Store as many prep samples for next time as possible, given the
 294              * number of output samples being generated.
 295              */
 296             ALuint SrcDataEnd{(DstSize*increment + DataPosFrac)>>FRACTIONBITS};
 297             if(SrcDataEnd >= static_cast<ALuint>(prepcount)+toread)
 298                 std::fill(std::begin(mChan[chan].PrevSamples),
 299                     std::end(mChan[chan].PrevSamples), 0.0f);
 300             else
 301             {
 302                 const size_t len{minz(al::size(mChan[chan].PrevSamples),
 303                     static_cast<ALuint>(prepcount)+toread-SrcDataEnd)};
 304                 std::copy_n(SrcData+SrcDataEnd, len, mChan[chan].PrevSamples);
 305                 std::fill(std::begin(mChan[chan].PrevSamples)+len,
 306                     std::end(mChan[chan].PrevSamples), 0.0f);
 307             }
 308
 309             /* Now resample, and store the result in the output buffer. */
 310             const float *ResampledData{mResample(&mState, SrcData+(MAX_RESAMPLER_PADDING>>1),
 311                 DataPosFrac, increment, {DstData, DstSize})};
 312
 313             StoreSamples(DstSamples, ResampledData, mChan.size(), mDstType, DstSize);
 314         }
 315
 316         /* Update the number of prep samples still available, as well as the
 317          * fractional offset.
 318          */
 319         DataPosFrac += increment*DstSize;
 320         mSrcPrepCount = mini(prepcount + static_cast<int>(toread - (DataPosFrac>>FRACTIONBITS)),
 321             MAX_RESAMPLER_PADDING);
 322         mFracOffset = DataPosFrac & FRACTIONMASK;
 323
 324         /* Update the src and dst pointers in case there's still more to do. */
 325         SamplesIn += SrcFrameSize*(DataPosFrac>>FRACTIONBITS);
 326         NumSrcSamples -= minu(NumSrcSamples, (DataPosFrac>>FRACTIONBITS));
 327
 328         dst = static_cast<al::byte*>(dst) + DstFrameSize*DstSize;
 329         pos += DstSize;
 330     }
 331
 332     *src = SamplesIn;
 333     *srcframes = NumSrcSamples;
 334
 335     return pos;
 336 }
 337
 338
 339 void ChannelConverter::convert(const void *src, float *dst, ALuint frames) const
 340 {
 341     if(mDstChans == DevFmtMono)
 342     {
 343         const float scale{std::sqrt(1.0f / static_cast<float>(PopCount(mChanMask)))};
 344         switch(mSrcType)
 345         {
 346 #define HANDLE_FMT(T) case T: Multi2Mono<T>(mChanMask, mSrcStep, scale, dst, src, frames); break
 347         HANDLE_FMT(DevFmtByte);
 348         HANDLE_FMT(DevFmtUByte);
 349         HANDLE_FMT(DevFmtShort);
 350         HANDLE_FMT(DevFmtUShort);
 351         HANDLE_FMT(DevFmtInt);
 352         HANDLE_FMT(DevFmtUInt);
 353         HANDLE_FMT(DevFmtFloat);
 354 #undef HANDLE_FMT
 355         }
 356     }
 357     else if(mChanMask == 0x1 && mDstChans == DevFmtStereo)
 358     {
 359         switch(mSrcType)
 360         {
 361 #define HANDLE_FMT(T) case T: Mono2Stereo<T>(dst, src, frames); break
 362         HANDLE_FMT(DevFmtByte);
 363         HANDLE_FMT(DevFmtUByte);
 364         HANDLE_FMT(DevFmtShort);
 365         HANDLE_FMT(DevFmtUShort);
 366         HANDLE_FMT(DevFmtInt);
 367         HANDLE_FMT(DevFmtUInt);
 368         HANDLE_FMT(DevFmtFloat);
 369 #undef HANDLE_FMT
 370         }
 371     }
 372 }