OutputHandler.hpp

// Copyright 2022 XMOS LIMITED.
// This Software is subject to the terms of the XMOS Public Licence: Version 1.
 
#pragma once
 
#include <cstdint>
#include <string>
#include <cassert>
#include <iostream>
#include <type_traits>
#include <functional>
 
#include "mic_array/frame_transfer.h"
 
#include <xcore/channel.h>
 
 
// This has caused problems previously, so just catch the problems here.
#if defined(MIC_COUNT) || defined(SAMPLE_COUNT) || defined(FRAME_COUNT)
# error Application must not define the following as precompiler macros: MIC_COUNT, SAMPLE_COUNT, FRAME_COUNT.
#endif
 
using namespace std;
 
namespace  mic_array {
 
  template <unsigned MIC_COUNT>
  class ChannelSampleTransmitter
  {
    private:
 
      chanend_t c_sample_out;
 
    public:
 
      ChannelSampleTransmitter() 
          : c_sample_out(0) { }
 
      ChannelSampleTransmitter(chanend_t c_sample_out)
          : c_sample_out(c_sample_out) { }
 
      void SetChannel(chanend_t c_sample_out);
 
      void ProcessSample(int32_t sample[MIC_COUNT]);
  };
 
 
 
  template <unsigned MIC_COUNT, 
            unsigned SAMPLE_COUNT, 
            template <unsigned, unsigned> class FrameTransmitter,
            unsigned FRAME_COUNT = 1>
  class FrameOutputHandler
  {
    private:
 
      unsigned current_frame = 0;
 
      unsigned current_sample = 0;
 
      int32_t frames[FRAME_COUNT][MIC_COUNT][SAMPLE_COUNT];
 
    public:
 
      FrameTransmitter<MIC_COUNT, SAMPLE_COUNT> FrameTx;
 
    public:
 
      FrameOutputHandler() { }
 
      FrameOutputHandler(FrameTransmitter<MIC_COUNT, SAMPLE_COUNT> frame_tx)
          : FrameTx(frame_tx) { }
 
      void OutputSample(int32_t sample[MIC_COUNT]);
  };
 
 
  template <unsigned MIC_COUNT, unsigned SAMPLE_COUNT>
  class ChannelFrameTransmitter
  {
    private:
 
      chanend_t c_frame_out;
 
    public:
 
      ChannelFrameTransmitter() : c_frame_out(0) { }
 
      ChannelFrameTransmitter(chanend_t c_frame_out) : c_frame_out(c_frame_out) { }
 
      void SetChannel(chanend_t c_frame_out);
 
      chanend_t GetChannel();
 
      void OutputFrame(int32_t frame[MIC_COUNT][SAMPLE_COUNT]);
  };
}
 
// Template function implementations below. //
 
 
template <unsigned MIC_COUNT>
void mic_array::ChannelSampleTransmitter<MIC_COUNT>::SetChannel(
    chanend_t c_sample_out)
{
  this->c_sample_out = c_sample_out;
}
 
 
template <unsigned MIC_COUNT>
void mic_array::ChannelSampleTransmitter<MIC_COUNT>::ProcessSample(
    int32_t sample[MIC_COUNT])
{
  ma_frame_tx(this->c_sample_out, sample, MIC_COUNT, 1);
}
 
 
 
template <unsigned MIC_COUNT, 
          unsigned SAMPLE_COUNT, 
          template <unsigned, unsigned> class FrameTransmitter,
          unsigned FRAME_COUNT>
void mic_array::FrameOutputHandler<MIC_COUNT,SAMPLE_COUNT,
                        FrameTransmitter,FRAME_COUNT>::OutputSample(
    int32_t sample[MIC_COUNT])
{
  auto* cur_frame = reinterpret_cast<int32_t (*)[SAMPLE_COUNT]>(
                        &this->frames[this->current_frame][0][0]);
  
  for(int k = 0; k < MIC_COUNT; k++) 
    cur_frame[k][this->current_sample] = sample[k];
  
  if(++current_sample == SAMPLE_COUNT){
    current_sample = 0;
    current_frame++;
    if(current_frame == FRAME_COUNT) current_frame = 0;
 
    FrameTx.OutputFrame( cur_frame );
  }
}
 
 
 
template <unsigned MIC_COUNT, unsigned SAMPLE_COUNT>
void mic_array::ChannelFrameTransmitter<MIC_COUNT,SAMPLE_COUNT>::SetChannel(
    chanend_t c_frame_out)
{
  this->c_frame_out = c_frame_out;
}
 
template <unsigned MIC_COUNT, unsigned SAMPLE_COUNT>
chanend_t mic_array::ChannelFrameTransmitter<MIC_COUNT,SAMPLE_COUNT>::GetChannel()
{
  return this->c_frame_out;
}
 
 
template <unsigned MIC_COUNT, unsigned SAMPLE_COUNT>
void mic_array::ChannelFrameTransmitter<MIC_COUNT,SAMPLE_COUNT>::OutputFrame(
    int32_t frame[MIC_COUNT][SAMPLE_COUNT])
{
  ma_frame_tx(this->c_frame_out, 
                  reinterpret_cast<int32_t*>(frame), 
                  MIC_COUNT, SAMPLE_COUNT);
}