re-organize sources

alacenc.cpp → ALACEncoderX.cpp

@@ -1,4 +1,4 @@
-#include "alacenc.h"
+#include "ALACEncoderX.h"
 #include "cautil.h"
 
 ALACEncoderX::ALACEncoderX(const AudioStreamBasicDescription &desc)

alacenc.h → ALACEncoderX.h

@@ -1,8 +1,7 @@
 #ifndef ALACENC_H
 #define ALACENC_H
 
-#include "iointer.h"
-#include "iencoder.h"
+#include "IEncoder.h"
 #include <stdint.h>
 #include <ALACEncoder.h>
 

composite.cpp → CompositeSource.cpp

@@ -1,4 +1,5 @@
-#include "composite.h"
+#include "CompositeSource.h"
+#include "strutil.h"
 
 size_t CompositeSource::readSamples(void *buffer, size_t nsamples)
 {

composite.h → CompositeSource.h

@@ -1,7 +1,7 @@
 #ifndef _COMPOSITE_H
 #define _COMPOSITE_H
 
-#include "iointer.h"
+#include "ISource.h"
 
 class CompositeSource: public ISeekableSource, public ITagParser,
         public IChapterParser

CoreAudioEncoder.h

@@ -3,8 +3,7 @@
 
 #include "CoreAudioToolbox.h"
 #include "AudioConverterX.h"
-#include "iointer.h"
-#include "iencoder.h"
+#include "IEncoder.h"
 
 class CoreAudioEncoder: public IEncoder, public IEncoderStat {
     AudioConverterX m_converter;

ISink.h

@@ -0,0 +1,18 @@
+#ifndef _ISINK_H
+#define _ISINK_H
+
+#include <string>
+
+struct ISink {
+    virtual ~ISink() {}
+    virtual void writeSamples(
+            const void *data, size_t len, size_t nsamples) = 0;
+};
+
+struct ITagStore {
+    virtual ~ITagStore() {}
+    virtual void setTag(const std::string &key, const std::string &value) = 0;
+};
+
+#endif
+

iointer.cpp → ISource.cpp

@@ -1,8 +1,9 @@
 #include <cstdio>
+#include <algorithm>
 #define WIN32_LEAN_AND_MEAN
 #define NOMINMAX
 #include <windows.h>
-#include "iointer.h"
+#include "ISource.h"
 
 namespace {
     static union uif_t {

iointer.h → ISource.h

@@ -1,11 +1,10 @@
-#ifndef _IOINTER_H
-#define _IOINTER_H
+#ifndef _ISOURCE_H
+#define _ISOURCE_H
 
 #include <vector>
 #include <map>
 #include <memory>
 #include "CoreAudio/CoreAudioTypes.h"
-#include "util.h"
 #include "chapters.h"
 
 struct ISource {
@@ -22,12 +21,6 @@ struct ISeekableSource: public ISource {
     virtual void seekTo(int64_t offset) = 0;
 };
 
-struct ISink {
-    virtual ~ISink() {}
-    virtual void writeSamples(
-            const void *data, size_t len, size_t nsamples) = 0;
-};
-
 struct ITagParser {
     virtual ~ITagParser() {}
     virtual const std::map<std::string, std::string> &getTags() const = 0;
@@ -38,35 +31,6 @@ struct IChapterParser {
     virtual const std::vector<chapters::entry_t> &getChapters() const = 0;
 };
 
-struct ITagStore {
-    virtual ~ITagStore() {}
-    virtual void setTag(const std::string &key, const std::string &value) = 0;
-};
-
-class FilterBase: public ISource {
-    std::shared_ptr<ISource> m_src;
-public:
-    FilterBase() {}
-    FilterBase(const std::shared_ptr<ISource> &src): m_src(src) {}
-    void setSource(const std::shared_ptr<ISource> &src) { m_src = src; }
-    ISource *source() { return m_src.get(); }
-    const std::shared_ptr<ISource> &sourcePtr() const { return m_src; }
-    uint64_t length() const { return m_src->length(); }
-    int64_t getPosition() { return m_src->getPosition(); }
-    const AudioStreamBasicDescription &getSampleFormat() const
-    {
-        return m_src->getSampleFormat();
-    }
-    const std::vector<uint32_t> *getChannels() const
-    {
-        return m_src->getChannels();
-    }
-    size_t readSamples(void *buffer, size_t nsamples)
-    {
-        return m_src->readSamples(buffer, nsamples);
-    }
-};
-
 size_t readSamplesFull(ISource *src, void *buffer, size_t nsamples);
 
 size_t readSamplesAsFloat(ISource *src, std::vector<uint8_t> *pivot,
@@ -82,4 +46,3 @@ size_t readSamplesAsFloat(ISource *src, std::vector<uint8_t> *pivot,
                           double *floatBuffer, size_t nsamples);
 
 #endif
-

TrimmedSource.h

@@ -1,7 +1,7 @@
 #ifndef RANGEDSOURCE_H
 #define RANGEDSOURCE_H
 
-#include "iointer.h"
+#include "ISource.h"
 
 class TrimmedSource: public ISeekableSource, public ITagParser {
     uint64_t m_start;

chanmap.cpp

@@ -1,6 +1,7 @@
 #include "chanmap.h"
 #include <numeric>
 #include <cassert>
+#include "strutil.h"
 
 namespace chanmap {
 
@@ -332,74 +333,3 @@ void getMappingToAAC(uint32_t bitmap, std::vector<uint32_t> *result)
 }
 
 } // namespace
-
-ChannelMapper::ChannelMapper(const std::shared_ptr<ISource> &source,
-                             const std::vector<uint32_t> &chanmap,
-                             uint32_t bitmap)
-    : FilterBase(source)
-{
-    const AudioStreamBasicDescription &asbd = source->getSampleFormat();
-    assert(chanmap.size() == asbd.mChannelsPerFrame);
-    assert(chanmap.size() <= 8);
-
-    for (size_t i = 0; i < chanmap.size(); ++i)
-        m_chanmap.push_back(chanmap[i] - 1);
-    if (bitmap) {
-        for (unsigned i = 0; i < 32; ++i, bitmap >>= 1)
-            if (bitmap & 1) m_layout.push_back(i + 1);
-    } else {
-        const std::vector<uint32_t> *orig = FilterBase::getChannels();
-        if (orig)
-            for (size_t i = 0; i < m_chanmap.size(); ++i)
-                m_layout.push_back(orig->at(m_chanmap[i]));
-    }
-    switch (asbd.mBytesPerFrame / asbd.mChannelsPerFrame) {
-    case 2:
-        m_process = &ChannelMapper::process16; break;
-    case 4:
-        m_process = &ChannelMapper::process32; break;
-    case 8:
-        m_process = &ChannelMapper::process64; break;
-    default:
-        assert(0);
-    }
-}
-
-template <typename T>
-size_t ChannelMapper::processT(T *buffer, size_t nsamples)
-{
-    unsigned nchannels = source()->getSampleFormat().mChannelsPerFrame;
-    const uint32_t *chanmap = &m_chanmap[0];
-    T work[8], *bp = buffer;
-
-    nsamples = source()->readSamples(buffer, nsamples);
-    for (size_t i = 0; i < nsamples; ++i, bp += nchannels) {
-        memcpy(work, bp, sizeof(T) * nchannels);
-        switch (nchannels) {
-        case 8: bp[7] = work[chanmap[7]];
-        case 7: bp[6] = work[chanmap[6]];
-        case 6: bp[5] = work[chanmap[5]];
-        case 5: bp[4] = work[chanmap[4]];
-        case 4: bp[3] = work[chanmap[3]];
-        case 3: bp[2] = work[chanmap[2]];
-        case 2: bp[1] = work[chanmap[1]];
-        case 1: bp[0] = work[chanmap[0]];
-        }
-    }
-    return nsamples;
-}
-
-size_t ChannelMapper::process16(void *buffer, size_t nsamples)
-{
-    return processT(static_cast<uint16_t *>(buffer), nsamples);
-}
-
-size_t ChannelMapper::process32(void *buffer, size_t nsamples)
-{
-    return processT(static_cast<uint32_t *>(buffer), nsamples);
-}
-
-size_t ChannelMapper::process64(void *buffer, size_t nsamples)
-{
-    return processT(static_cast<uint64_t *>(buffer), nsamples);
-}

chanmap.h

@@ -2,8 +2,9 @@
 #define _CHANMAP_H
 
 #include <stdint.h>
+#include <string>
+#include <vector>
 #include "CoreAudio/CoreAudioTypes.h"
-#include "iointer.h"
 
 namespace chanmap {
     const int kAudioChannelLayoutTag_AAC_7_1_Rear = 0x01000008;
@@ -29,27 +30,4 @@ namespace chanmap {
     }
 }
 
-class ChannelMapper: public FilterBase {
-    std::vector<uint32_t> m_chanmap;
-    std::vector<uint32_t> m_layout;
-    size_t (ChannelMapper::*m_process)(void *, size_t);
-public:
-    ChannelMapper(const std::shared_ptr<ISource> &source,
-                  const std::vector<uint32_t> &chanmap, uint32_t bitmap=0);
-    const std::vector<uint32_t> *getChannels() const
-    {
-        return m_layout.size() ? &m_layout : 0;
-    }
-    size_t readSamples(void *buffer, size_t nsamples)
-    {
-        return (this->*m_process)(buffer, nsamples);
-    }
-private:
-    template <typename T>
-    size_t processT(T *buffer, size_t nsamples);
-    size_t process16(void *buffer, size_t nsamples);
-    size_t process32(void *buffer, size_t nsamples);
-    size_t process64(void *buffer, size_t nsamples);
-};
-
 #endif

cuesheet.cpp

@@ -4,11 +4,11 @@
 #include <regex>
 #include "cuesheet.h"
 #include "metadata.h"
-#include "composite.h"
-#include "nullsource.h"
+#include "CompositeSource.h"
+#include "NullSource.h"
 #include "TrimmedSource.h"
 #include "expand.h"
-#include "inputfactory.h"
+#include "InputFactory.h"
 #include "playlist.h"
 
 static inline

cuesheet.h

@@ -4,7 +4,6 @@
 #include <vector>
 #include <map>
 #include "util.h"
-#include "iointer.h"
 #include "playlist.h"
 
 template <typename CharT>

filters/ChannelMapper.cpp

@@ -0,0 +1,73 @@
+#include <cassert>
+#include "ChannelMapper.h"
+
+ChannelMapper::ChannelMapper(const std::shared_ptr<ISource> &source,
+                             const std::vector<uint32_t> &chanmap,
+                             uint32_t bitmap)
+    : FilterBase(source)
+{
+    const AudioStreamBasicDescription &asbd = source->getSampleFormat();
+    assert(chanmap.size() == asbd.mChannelsPerFrame);
+    assert(chanmap.size() <= 8);
+
+    for (size_t i = 0; i < chanmap.size(); ++i)
+        m_chanmap.push_back(chanmap[i] - 1);
+    if (bitmap) {
+        for (unsigned i = 0; i < 32; ++i, bitmap >>= 1)
+            if (bitmap & 1) m_layout.push_back(i + 1);
+    } else {
+        const std::vector<uint32_t> *orig = FilterBase::getChannels();
+        if (orig)
+            for (size_t i = 0; i < m_chanmap.size(); ++i)
+                m_layout.push_back(orig->at(m_chanmap[i]));
+    }
+    switch (asbd.mBytesPerFrame / asbd.mChannelsPerFrame) {
+    case 2:
+        m_process = &ChannelMapper::process16; break;
+    case 4:
+        m_process = &ChannelMapper::process32; break;
+    case 8:
+        m_process = &ChannelMapper::process64; break;
+    default:
+        assert(0);
+    }
+}
+
+template <typename T>
+size_t ChannelMapper::processT(T *buffer, size_t nsamples)
+{
+    unsigned nchannels = source()->getSampleFormat().mChannelsPerFrame;
+    const uint32_t *chanmap = &m_chanmap[0];
+    T work[8], *bp = buffer;
+
+    nsamples = source()->readSamples(buffer, nsamples);
+    for (size_t i = 0; i < nsamples; ++i, bp += nchannels) {
+        memcpy(work, bp, sizeof(T) * nchannels);
+        switch (nchannels) {
+        case 8: bp[7] = work[chanmap[7]];
+        case 7: bp[6] = work[chanmap[6]];
+        case 6: bp[5] = work[chanmap[5]];
+        case 5: bp[4] = work[chanmap[4]];
+        case 4: bp[3] = work[chanmap[3]];
+        case 3: bp[2] = work[chanmap[2]];
+        case 2: bp[1] = work[chanmap[1]];
+        case 1: bp[0] = work[chanmap[0]];
+        }
+    }
+    return nsamples;
+}
+
+size_t ChannelMapper::process16(void *buffer, size_t nsamples)
+{
+    return processT(static_cast<uint16_t *>(buffer), nsamples);
+}
+
+size_t ChannelMapper::process32(void *buffer, size_t nsamples)
+{
+    return processT(static_cast<uint32_t *>(buffer), nsamples);
+}
+
+size_t ChannelMapper::process64(void *buffer, size_t nsamples)
+{
+    return processT(static_cast<uint64_t *>(buffer), nsamples);
+}

filters/ChannelMapper.h

@@ -0,0 +1,29 @@
+#ifndef _CHANNELMAPPER_H
+#define _CHANNELMAPPER_H
+
+#include "FilterBase.h"
+
+class ChannelMapper: public FilterBase {
+    std::vector<uint32_t> m_chanmap;
+    std::vector<uint32_t> m_layout;
+    size_t (ChannelMapper::*m_process)(void *, size_t);
+public:
+    ChannelMapper(const std::shared_ptr<ISource> &source,
+                  const std::vector<uint32_t> &chanmap, uint32_t bitmap=0);
+    const std::vector<uint32_t> *getChannels() const
+    {
+        return m_layout.size() ? &m_layout : 0;
+    }
+    size_t readSamples(void *buffer, size_t nsamples)
+    {
+        return (this->*m_process)(buffer, nsamples);
+    }
+private:
+    template <typename T>
+    size_t processT(T *buffer, size_t nsamples);
+    size_t process16(void *buffer, size_t nsamples);
+    size_t process32(void *buffer, size_t nsamples);
+    size_t process64(void *buffer, size_t nsamples);
+};
+
+#endif