在别的论坛看到的就转过来了，和大家分享一下
在此感谢原作者  john_lee  分享



经过了两三个月的痛苦，USB 协议栈的 Audio Device Class 框架已具雏形了，用了两三天时间，使用这个框架实战了一个基于新唐 M0 的最简单的 USB Audio 程序，可以作为 USB 声卡。
            附件中是生成的 hex 文件，可以运行在菜农助学板上，烧写时需要配置 Config0 中的时钟选择为 external 12Mhz。
代码空间开销：
   text    data     bss     dec     hex filename
   1580     244     168    1992     7c8 .defaultadc.elf

整个程序占用 flash 大约 1.8K，除去中断向量表、系统启动、硬件初始化和 I2S功能的空间开销，框架在这个示例程序中所占空间大约 1.2K 左右，随着功能多少的变化，框架的开销也会有变化，但对比目前市面上的各种 USB 协议栈驱动，我想它应该是开销最小的框架了。
先贴出应用程序，恭请各位提提意见，我好改进框架，谢谢。
#include <usb/hal/numicro>                                  // USB HAL(Hardware Abstract Layer)，新唐 Numicro
#include <usb/adc>                                          // USB Audio Device Class
#include <numicro/nuc/sfr/i2s>                              // I2S Register

void i2s_start();

using namespace usb;                                        // 使用 usb 名空间
using namespace adc;                                        // 使用 usb adc(audio device class）名空间

template<typename PARENT, uint8_t ID>                       // 定式
struct it_t : it_impl_t<                                    // 定义 Input Terminal 类模板
            it_t, PARENT, ID,                               // 定式
            0                                               // 指定 String ID，为 0 表示不定义
        > {
    using input_t = typename it_t::it_impl_t;               // 为本类指定一个“别名”，方便在定义 Entities 集合时标识
};

template<typename PARENT, uint8_t ID>
struct ot_t : ot_impl_t<                                    // 定义 Output Terminal 类模板
            ot_t, PARENT, ID,
            0
        > {
    using output_t = typename ot_t::ot_impl_t;
};

template<typename PARENT>                                   // 定式
struct tuple_t : entity_tuple_t<                            // 定义 Entities 集合类，其中可以加入以上定义的各个 Entity 类模板
            PARENT,                                         // 定式
            it_t,                                           // 已定义的类模板
            ot_t                                            // 已定义的类模板
        > {
    using typename tuple_t::entity_tuple_t::input_t;        // 导入各个 Terminal 的别名
    using typename tuple_t::entity_tuple_t::output_t;       // ...
    struct __attribute__((packed)) entities_descriptor_t    // 定义 Entities 集合的描述符
        :   td_t<                                           // 定义 Terminal 描述符
                input_t,                                    // 使用已导入的别名，用于确定本 Entity ID，
                USB_STREAMING,                              // 指定 Terminal 类型
                cluster_t<                                  // 定义 Channel（声道） Cluster，其中可以加入任意声道
                    0,                                      // 指定 String ID
                    cluster_channel_t::LEFT_FRONT,          // 指定 Left Front
                    cluster_channel_t::RIGHT_FRONT          // 指定 Right Front
                >
            >,
            td_t<                                           // 定义 Terminal 描述符
                output_t,                                   // 使用已导入的别名，用于确定本 Entity ID，
                SPEAKER,                                    // 指定 Terminal 类型
                input_t                                     // 指定本输出 Terminal 的数据来源
            > { };
};

template<typename PARENT, uint32_t PARAM>                   // 定式
class ep_t : public streaming::data::out::ep_impl_t<        // 定义 Audio Data Endpoint（数据端点）类
            ep_t, PARENT, PARAM,                            // 定式
            core::transfer::iso::sync_t::SYNC,              // 指定端点的 sync 类型
            false,                                          // 指定 bmAttributes 的 sampling frequency，参见 USB Audio 规范
            false,                                          // 指定 bmAttributes 的 pitch，参见 USB Audio 规范
            false,                                          // 指定 bmAttributes 的 MaxPacketsOnly， 参见 USB Audio 规范
            streaming::UNDEFINED,                           // 指定 bLockDelayUnits， 参见 USB Audio 规范
            0                                               // 指定 wLockDelay， 参见 USB Audio 规范
        > { };

#define SAMPLE_RATE     16000

struct {                                                    // 定义 Audio Data 缓冲区
    union {
        struct {
            uint8_t wrpos;                                  // 写缓冲指针
            uint8_t rdpos;                                  // 读缓冲指针
        };
        uint16_t pos;
    };
    uint32_t data[64 * 2 / sizeof(uint32_t)];               // 缓冲数据区，包含两个 packet
} buffer;

template<typename PARENT, uint32_t PARAM>                   // 定式
class ifc_t : public control::if_impl_t<                    // 定义 AudioControl Interface（控制接口）类
            ifc_t, PARENT, PARAM,                           // 定式
            0                                               // 指定 String ID
        > { };

template<typename PARENT, uint32_t PARAM>                   // 定式
class ifs_t : public streaming::if_impl_t<                  // 定义 AudioStream Interface（流接口）类
            ifs_t, PARENT, PARAM,                           // 定式
            0,                                              // 指定 String ID
            typename tuple_t<PARENT>::input_t,              // 指定连接到的 terminal
            ep_t                                            // 指定本接口包含的数据端点（暂不支持同步端点）
        > {
public:
    template<uint8_t N> using ep_t = typename core::elem_t<N, typename ifs_t::tuple_t>::type;

    struct __attribute__((packed)) descriptor_t                                     // 定义流接口描述符
            :   core::descriptor_t<core::descriptor::std_if_t<ifs_t, 0, 0, 0>>,     // Alternative 0
                core::descriptor_t<core::descriptor::std_if_t<ifs_t, 1, 0, 0>,      // Alternative 1
                    streaming::pcm_descriptor_t<                                    // 定义 PCM 描述符
                        ifs_t,              // 定式
                        1,                  // bDelay
                        2,                  // bNrChannels
                        2,                  // bSubframeSize
                        16,                 // bBitResolution
                        true,               // 指定固定采样
                        SAMPLE_RATE         // 采样率
                    >,
                    ep_t<0>                 // 指定 Alternative 1 所包含的 Endpoint
                > { };

    __INLINE bool set_interface(uint_fast8_t alternative)   // Set Interface 处理
    {
        if (alternative) {
            first = true;
            this->read(buffer.data, 64);                    // 读 packet
            buffer.pos = 0;
        }
        return true;
    }
    __INLINE void read_complete(uint_fast16_t length)       // 读 packet 完成
    {
        uint_fast8_t pos = buffer.wrpos;
        pos ^= 64 / sizeof(uint32_t);
        buffer.wrpos = pos;
        this->read(&buffer.data[pos], 64);                  // 读 packet
        if (first) {
            first = 0;
            i2s_start();                                    // 启动 I2S
        }
    }

private:
    uint8_t first;
};

template<typename PARENT, uint32_t PARAM>       // 定式
class fn_t : public adc::fn_impl_t<             // 定义 Function
            fn_t, PARENT, PARAM,                // 定式
            0,                                  // 指定 String ID
            0x100,                              // 指定 bcdADC，Release Number
            ifc_t,                              // 已定义的 AudioControl Interface
            tuple_t<fn_t<PARENT, PARAM>>,       // 已定义的 Entiies 集合
            ifs_t                               // 已定义的 AudioStream Interface，可连续加入多个
        > { };

class usbd_t : public core::usbd_impl_t<        // 定义 USB 类
        usbd_t,                                 // 定式
        0x110,                  // bcdUSB
        0,                      // bDeviceClass
        0,                      // bDeviceSubClass
        0,                      // bDeviceProtocol
        0x0416,                 // idVendor
        0x5011,                 // idProduct
        0x100,                  // bcdDevice
        1,                      // iManufacture
        2,                      // iProduct
        3,                      // iSerialNumber
        true,                   // bmAttributes, Bus Powered
        false,                  // bmAttributes, Self Powered
        false,                  // bmAttributes, Remote Wakeup
        50_mA,                  // bMaxPower
        0,                      // iConfiguration
        fn_t> {                 // 已定义的 Function，可连续加入多个 Function 和 Interface

public:
    __INLINE usbd_t() { }

#if 1
    __INLINE bool data_out(uint_fast8_t type, uint_fast8_t request, uint_fast16_t value, uint_fast16_t index, uint_fast16_t length)
    {
        out();
        return true;
    }
    __INLINE bool data_in(uint_fast8_t type, uint_fast8_t request, uint_fast16_t value, uint_fast16_t index, uint_fast16_t length)
    {
        in();
        return true;
    }
#endif

    __INLINE const uint8_t* get_string_descriptor(uint_fast8_t index, uint_fast16_t lang_id)    // GetDescriptor(String) 处理
    {
        static const string_langid_t<langid_t::English_UnitedStates> desc0;
        static const string_t<u'j', u'.', u'y', u'.', u'l', u'e', u'e', u'@', u'y', u'e', u'a', u'h', u'.', u'n', u'e', u't'> desc1;
        static const string_t<u'U', u'S', u'B', u' ', u'A', u'u', u'd', u'i', u'o'> desc2;
        static const string_t<u'0', u'0', u'0', u'0'> desc3;
        static const uint8_t* const descriptor[] {
            reinterpret_cast<const uint8_t*>(&desc0),
            reinterpret_cast<const uint8_t*>(&desc1),
            reinterpret_cast<const uint8_t*>(&desc2),
            reinterpret_cast<const uint8_t*>(&desc3)
        };
        return index < sizeof(descriptor) / sizeof(descriptor[0]) ? descriptor[index] : nullptr;
    }
};

usbd_t usbd;                // 定义 USB 类对象

void usbd_isr()             // USBD_IRQn 中断向量 handler
{
    usbd.isr();             // 调用 USB 类的中断处理
}

void i2s_isr()              // I2S_IRQn 中断向量 handler
{
    using namespace sfr::i2s;
    if (I2S.STATUS().TXUDF) {
        I2S.STATUS(0).TXUDF(1);
        I2S.CON(0);
        I2S.IE(0);
        return;
    }
    if (buffer.pos == 0x400 || buffer.pos == 0x1014) {
        I2S.IE(0).TXUDFIE(1);
        return;
    }
    // 从 Audio Data 缓冲填充数据到 I2S 发送 FIFO
    uint_fast8_t rdpos{ buffer.rdpos };
    do {
        I2S.TXFIFO = buffer.data[rdpos++];
        if (rdpos == sizeof(buffer.data) / 4)
            rdpos = 0;
    } while (I2S.STATUS().TXFULL == 0);
    buffer.rdpos = rdpos;
    // 调整 I2S 速率
    uint_fast16_t pos{ buffer.pos };
    if (pos == 0xc00 || pos == 0x1c10) {        // 加快
        I2S.CLKDIV(0).BCLK_DIV(45);
    } else if (pos == 0 || pos == 0x1010) {     // 减慢
        I2S.CLKDIV(0).BCLK_DIV(47);
    } else
        I2S.CLKDIV(0).BCLK_DIV(46);             // 恢复正常
}

void i2s_start()                                // I2S 启动
{
    using namespace sfr::i2s;
    do {
        I2S.TXFIFO = 0;
    } while (I2S.STATUS().TXFULL == 0);
    I2S.CON(0)
        .I2SEN(1)
        .TXEN(1)
        .WORDWIDTH(1)
        .FORMAT(1)
        .TXTH(4);
    I2S.IE(0).TXTHIE(1);
}

int main()
{
    using namespace sfr::i2s;
    I2S.CLKDIV(0).BCLK_DIV(46);                 // 设置 I2S 默认速率
    *reinterpret_cast<volatile uint32_t*>(0xe000e100) = 1 << I2S_IRQn;  // NVIC：允许 I2S 中断
    usbd.open(true);                            // 初始化 usb 对象
    while (true);
}


程序中所有的类和模板的层次结构：
usbd_t                 USB device 的封装
|
+--fn_t<...>           Interface 的容器
   |
   +--ifc_t<...>       Audio Control Interface 的模板封装
   |
   +--tuple_t<...>     Terminal 和 Unit 的容器
   |  |
   |  +--it_t<...>     Input Terminal 的模板封装
   |  |
   |  +--ot_t<...>     Output Terminal 的模板封装
   |
   +--ifs_t<...>       Audio Stream Interface 的模板封装
      |
      +--ep_t<...>     Audio Data Endpoint 的模板封装