libcw/cwDynRefTbl.cpp

#include "cwCommon.h"
#include "cwLog.h"
#include "cwCommonImpl.h"
#include "cwMem.h"
#include "cwText.h"
#include "cwObject.h"
#include "cwMidi.h"
#include "cwDynRefTbl.h"

namespace cw
{
  namespace dyn_ref_tbl
  {
    typedef struct dyn_ref_tbl_str
    {
      dyn_ref_t* dynRefA;
      unsigned   dynRefN;
      
    } dyn_ref_tbl_t;

    dyn_ref_tbl_t* _handleToPtr( handle_t h )
    { return handleToPtr<handle_t,dyn_ref_tbl_t>(h); }
        
    rc_t _destroy( dyn_ref_tbl_t* p )
    {
      rc_t rc = kOkRC;

      auto relse = [](dyn_ref_t& x) { mem::release(x.marker); };
            
      std::for_each(p->dynRefA, p->dynRefA+p->dynRefN, relse );
      mem::release(p->dynRefA);
      mem::release(p);
      return rc;
    }

    rc_t _parse_cfg( dyn_ref_tbl_t* p, const object_t* cfg )
    {
      rc_t rc = kOkRC;
      
      // parse the dynamics ref. array
      p->dynRefN = cfg->child_count();
  
      if( p->dynRefN == 0 )
        cwLogWarning("The dynamic reference array cfg. is empty.");
      else
      {
        p->dynRefA = mem::allocZ<dyn_ref_t>(p->dynRefN);
  
        for(unsigned i=0; i<p->dynRefN; ++i)
        {
          const object_t* r = cfg->child_ele(i);
          const char* marker = nullptr;
          
          if((rc = r->getv("mark", marker,
                           "level", p->dynRefA[i].level,
                           "vel", p->dynRefA[i].velocity)) != kOkRC )
          {
            rc = cwLogError(kSyntaxErrorRC,"Error parsing the dynamics reference array.");
            goto errLabel;
          }
    
          p->dynRefA[i].marker = mem::duplStr(marker);
        }
      }

  
    errLabel:

      return rc;
    }
  }
}

cw::rc_t cw::dyn_ref_tbl::create( handle_t& hRef, const object_t* cfg )
{
  rc_t rc;
  if((rc = destroy(hRef)) != kOkRC )
    return rc;

  dyn_ref_tbl_t* p = mem::allocZ<dyn_ref_tbl_t>();

  if((rc = _parse_cfg( p, cfg )) != kOkRC )
  {
    rc = cwLogError(rc,"Dynamics reference table parse failed.");
    goto errLabel;
  }

  hRef.set(p);
  
 errLabel:

  return rc;
}

cw::rc_t cw::dyn_ref_tbl::destroy( handle_t& hRef )
{
  rc_t rc = kOkRC;
  
  if(!hRef.isValid())
    return rc;

  dyn_ref_tbl_t* p = _handleToPtr(hRef);

  if((rc = _destroy(p)) != kOkRC )
    return rc;

  hRef.clear();
  
  return rc;
}

const char* cw::dyn_ref_tbl::level_to_marker( handle_t h, unsigned level )
{
  dyn_ref_tbl_t* p = _handleToPtr(h);
  for(unsigned i=0; i<p->dynRefN; ++i)
    if( p->dynRefA[i].level )
      return p->dynRefA[i].marker;
  return nullptr;
}

unsigned    cw::dyn_ref_tbl::marker_to_level( handle_t h, const char* marker )
{
  dyn_ref_tbl_t* p = _handleToPtr(h);
  for(unsigned i=0; i<p->dynRefN; ++i)
    if( textIsEqual(p->dynRefA[i].marker,marker) )
      return p->dynRefA[i].level;
  return kInvalidIdx;
}

cw::midi::byte_t     cw::dyn_ref_tbl::level_to_velocity( handle_t h , unsigned level )
{
  dyn_ref_tbl_t* p = _handleToPtr(h);
  for(unsigned i=0; i<p->dynRefN; ++i)
    if( p->dynRefA[i].level == level )
      return p->dynRefA[i].velocity;
  return midi::kInvalidMidiByte;
}

unsigned    cw::dyn_ref_tbl::velocity_to_level( handle_t h, midi::byte_t vel )
{
  dyn_ref_tbl_t* p = _handleToPtr(h);
  
  for(unsigned i=0; i<p->dynRefN; ++i)
    if( p->dynRefA[i].velocity > vel )
    {
      midi::byte_t d0 = p->dynRefA[i].velocity - vel;
      
      midi::byte_t d1 = i>0 ? (vel -  p->dynRefA[i-1].velocity) : d0;

      unsigned j = d0 <= d1 ? i : i-1;

      return p->dynRefA[j].level;
    }

  return p->dynRefA[ p->dynRefN-1 ].velocity;
}

void cw::dyn_ref_tbl::report( handle_t h )
{
  dyn_ref_tbl_t* p = _handleToPtr(h);

  auto rpt = [](dyn_ref_t& x) { printf("%2i %3i %s\n",x.level,x.velocity,x.marker); };
  
  std::for_each(p->dynRefA,p->dynRefA+p->dynRefN, rpt );  
}