c6_cam_audio.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "c6_camera_server.h"
#include "ra8_attributes.h"
#include "ra8_audio.h"
#include "ra8_audio_source_pdm.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_err.h"
#include "ra8_register_guard.h"

typedef enum : uint32_t {
  k_c6_cam_audio_rate_hz       = 16000U,  
  k_c6_cam_audio_frame_samples = 256U,    
  k_c6_cam_audio_ring_samples  = 16000U,  
  k_c6_cam_audio_settle_ms     = 300U,    
  k_c6_cam_audio_discard       = 1024U,   
  k_c6_cam_audio_poll_attempts = 500000U, 
  k_c6_cam_audio_irq_priority  = 5U,      
  k_c6_cam_audio_bank_count    = 2U,      
  k_c6_cam_audio_gain          = 16U,     
  k_c6_cam_wav_header_bytes    = 44U,     
  k_c6_cam_wav_sample_bytes    = 2U,      
  k_c6_cam_wav_capacity =
    k_c6_cam_wav_header_bytes +
    (k_c6_cam_audio_ring_samples * k_c6_cam_wav_sample_bytes), 
  k_c6_cam_byte_mask            = 0xFFU, 
  k_c6_cam_shift_24             = 24U,   
  k_c6_cam_ms_per_second        = 1000U, 
  k_c6_cam_wav_riff_overhead    = 36U,   
  k_c6_cam_wav_audio_format_off = 20U,   
  k_c6_cam_wav_channels_off     = 22U,   
  k_c6_cam_wav_byte_rate_off    = 28U,   
  k_c6_cam_wav_bits_off         = 34U,   
  k_c6_cam_wav_data_size_off    = 40U,   
} c6_cam_audio_cfg_t;

typedef struct {
  uint32_t write_index;         
  uint32_t sample_count;        
  uint32_t oldest_timestamp_ms; 
} c6_cam_audio_bank_t;

static ra8_audio_source_t           s_audio_source;
static ra8_audio_source_pdm_state_t s_audio_state;
alignas(4) static int32_t s_audio_frame[k_c6_cam_audio_frame_samples];

[[gnu::section(".sdram_data"),
  gnu::aligned(
    32)]] static int32_t s_audio_ring[k_c6_cam_audio_bank_count][k_c6_cam_audio_ring_samples];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_audio_wav[k_c6_cam_wav_capacity];

static volatile uint8_t    s_audio_active_bank;
static c6_cam_audio_bank_t s_audio_banks[k_c6_cam_audio_bank_count];

static const uint8_t s_wav_tag_riff[]    = {'R', 'I', 'F', 'F'};
static const uint8_t s_wav_tag_wavefmt[] = {'W', 'A', 'V', 'E', 'f', 'm', 't', ' '};
static const uint8_t s_wav_tag_data[]    = {'d', 'a', 't', 'a'};

RA8_INTERNAL static void internal_c6_cam_audio_put_u16(uint8_t* out, uint16_t value)
{
  out[0] = (uint8_t)(value & (uint16_t)k_c6_cam_byte_mask);
  out[1] = (uint8_t)(value >> 8U);
}

RA8_INTERNAL static void internal_c6_cam_audio_put_u32(uint8_t* out, uint32_t value)
{
  out[0] = (uint8_t)(value & (uint32_t)k_c6_cam_byte_mask);
  out[1] = (uint8_t)((value >> 8U) & (uint32_t)k_c6_cam_byte_mask);
  out[2] = (uint8_t)((value >> 16U) & (uint32_t)k_c6_cam_byte_mask);
  out[3] = (uint8_t)(value >> (uint32_t)k_c6_cam_shift_24);
}

RA8_INTERNAL static int16_t internal_c6_cam_audio_s16(int32_t sample)
{
  const int64_t amplified = (int64_t)sample * (int64_t)k_c6_cam_audio_gain;
  int32_t       scaled    = (int32_t)(amplified / 16);
  if (scaled > INT16_MAX) {
    scaled = INT16_MAX;
  } else if (scaled < INT16_MIN) {
    scaled = INT16_MIN;
  }
  return (int16_t)scaled;
}

RA8_INTERNAL static void internal_c6_cam_audio_on_frame(void* ctx, const ra8_audio_frame_t* frame)
{
  (void)ctx;
  if ((frame == nullptr) || (frame->data == nullptr) ||
      (frame->format != k_ra8_audio_format_pcm_s32le)) {
    return;
  }
  const uint8_t        bank    = s_audio_active_bank;
  c6_cam_audio_bank_t* meta    = &s_audio_banks[bank];
  const int32_t*       samples = (const int32_t*)frame->data;
  for (uint32_t i = 0U; i < frame->sample_count; ++i) {
    s_audio_ring[bank][meta->write_index] = samples[i];
    meta->write_index += 1U;
    if (meta->write_index == (uint32_t)k_c6_cam_audio_ring_samples) {
      meta->write_index = 0U;
    }
  }
  if (meta->sample_count < (uint32_t)k_c6_cam_audio_ring_samples) {
    const uint32_t room = (uint32_t)k_c6_cam_audio_ring_samples - meta->sample_count;
    meta->sample_count += (frame->sample_count < room) ? frame->sample_count : room;
  }
  const uint32_t retained_ms =
    (meta->sample_count * (uint32_t)k_c6_cam_ms_per_second) / (uint32_t)k_c6_cam_audio_rate_hz;
  const uint32_t frame_end_ms =
    frame->timestamp_ms +
    ((frame->sample_count * (uint32_t)k_c6_cam_ms_per_second) / (uint32_t)k_c6_cam_audio_rate_hz);
  meta->oldest_timestamp_ms = frame_end_ms - retained_ms;
}

RA8_INTERNAL static void internal_c6_cam_audio_write_header(uint32_t samples)
{
  const uint32_t data_bytes = samples * (uint32_t)k_c6_cam_wav_sample_bytes;
  (void)memcpy(&s_audio_wav[0], s_wav_tag_riff, sizeof(s_wav_tag_riff));
  internal_c6_cam_audio_put_u32(&s_audio_wav[4], (uint32_t)k_c6_cam_wav_riff_overhead + data_bytes);
  (void)memcpy(&s_audio_wav[8], s_wav_tag_wavefmt, sizeof(s_wav_tag_wavefmt));
  internal_c6_cam_audio_put_u32(&s_audio_wav[16], 16U);
  internal_c6_cam_audio_put_u16(&s_audio_wav[k_c6_cam_wav_audio_format_off], 1U);
  internal_c6_cam_audio_put_u16(&s_audio_wav[k_c6_cam_wav_channels_off], 1U);
  internal_c6_cam_audio_put_u32(&s_audio_wav[24], (uint32_t)k_c6_cam_audio_rate_hz);
  internal_c6_cam_audio_put_u32(&s_audio_wav[k_c6_cam_wav_byte_rate_off],
                                (uint32_t)k_c6_cam_audio_rate_hz *
                                  (uint32_t)k_c6_cam_wav_sample_bytes);
  internal_c6_cam_audio_put_u16(&s_audio_wav[32], (uint16_t)k_c6_cam_wav_sample_bytes);
  internal_c6_cam_audio_put_u16(&s_audio_wav[k_c6_cam_wav_bits_off], 16U);
  (void)memcpy(&s_audio_wav[36], s_wav_tag_data, sizeof(s_wav_tag_data));
  internal_c6_cam_audio_put_u32(&s_audio_wav[k_c6_cam_wav_data_size_off], data_bytes);
}
 
ra8_err_t c6_cam_audio_start(void)
{
  ra8_err_t err = ra8_board_pdm_mic_route();
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_board_pdm_mic_config_t board = {};
  err                              = ra8_board_pdm_mic_get_config(k_ra8_board_pdm_mic1, &board);
  if (err != k_ra8_ok) {
    return err;
  }
  if (board.sample_rate_hz != (uint32_t)k_c6_cam_audio_rate_hz) {
    return k_ra8_err_invalid_state;
  }
  const ra8_audio_source_pdm_cfg_t cfg = {
    .pdm               = board.pdm,
    .sample_rate_hz    = board.sample_rate_hz,
    .samples_per_frame = (uint32_t)k_c6_cam_audio_frame_samples,
    .settle_ms         = (uint32_t)k_c6_cam_audio_settle_ms,
    .discard_samples   = (uint32_t)k_c6_cam_audio_discard,
    .poll_attempts     = (uint32_t)k_c6_cam_audio_poll_attempts,
    .channel           = board.channel,
    .valid_bits        = board.valid_bits,
    .irq_priority      = (uint8_t)k_c6_cam_audio_irq_priority,
  };
  err = ra8_audio_source_pdm_init(&s_audio_source, &s_audio_state, &cfg);
  if (err != k_ra8_ok) {
    return err;
  }
  const ra8_audio_buffer_t buffer = {
    .data     = s_audio_frame,
    .capacity = (uint32_t)sizeof(s_audio_frame),
  };
  err = ra8_audio_source_stream_start(&s_audio_source,
                                      &buffer,
                                      internal_c6_cam_audio_on_frame,
                                      nullptr);
  if (err != k_ra8_ok) {
    (void)ra8_audio_source_stop(&s_audio_source);
  }
  return err;
}
 
ra8_err_t
c6_cam_audio_snapshot_wav(const uint8_t** out_wav, uint32_t* out_bytes, uint32_t* out_timestamp_ms)
{
  if ((out_wav == nullptr) || (out_bytes == nullptr) || (out_timestamp_ms == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out_wav          = nullptr;
  *out_bytes        = 0U;
  *out_timestamp_ms = 0U;
  ra8_register_guard_t guard;
  ra8_register_guard_enter(&guard);
  const uint8_t  snapshot_bank = s_audio_active_bank;
  const uint32_t samples       = s_audio_banks[snapshot_bank].sample_count;
  if (samples == 0U) {
    ra8_register_guard_exit(&guard);
    return k_ra8_err_no_data;
  }
  const uint32_t write        = s_audio_banks[snapshot_bank].write_index;
  const uint32_t timestamp_ms = s_audio_banks[snapshot_bank].oldest_timestamp_ms;
  const uint8_t  capture_bank = snapshot_bank ^ 1U;
  s_audio_banks[capture_bank] = (c6_cam_audio_bank_t){};
  s_audio_active_bank         = capture_bank;
  ra8_register_guard_exit(&guard);
 
  const uint32_t oldest = (samples == (uint32_t)k_c6_cam_audio_ring_samples) ? write : 0U;
  internal_c6_cam_audio_write_header(samples);
  for (uint32_t i = 0U; i < samples; ++i) {
    uint32_t ring_index = oldest + i;
    if (ring_index >= (uint32_t)k_c6_cam_audio_ring_samples) {
      ring_index -= (uint32_t)k_c6_cam_audio_ring_samples;
    }
    const uint16_t pcm =
      (uint16_t)internal_c6_cam_audio_s16(s_audio_ring[snapshot_bank][ring_index]);
    internal_c6_cam_audio_put_u16(
      &s_audio_wav[k_c6_cam_wav_header_bytes + (i * (uint32_t)k_c6_cam_wav_sample_bytes)],
      pcm);
  }
  *out_wav = s_audio_wav;
  *out_bytes =
    (uint32_t)k_c6_cam_wav_header_bytes + (samples * (uint32_t)k_c6_cam_wav_sample_bytes);
  *out_timestamp_ms = timestamp_ms;
  return k_ra8_ok;
}