libcw/cwScoreFollower.cpp

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

#include "cwDynRefTbl.h"
#include "cwScoreParse.h"
#include "cwSfScore.h"
#include "cwSfMatch.h"
#include "cwSfTrack.h"
#include "cwPerfMeas.h"

#include "cwScoreFollowerPerf.h"
#include "cwScoreFollower.h"
#include "cwMidiState.h"

#include "cwSvgScoreFollow.h"


namespace cw
{
  namespace score_follower
  {
    typedef struct meas_set_str
    {
      unsigned vsi;
      unsigned nsi;
    } meas_set_t;
    
    typedef struct score_follower_str
    {
      bool         enableFl;
      double       srate;
      unsigned     search_area_locN;
      unsigned     key_wnd_locN;
      char*        score_csv_fname;

      bool                deleteScoreFl;
      sfscore::handle_t   scoreH;
      sftrack::handle_t   trackH;
      //perf_meas::handle_t measH;
      
      unsigned*    result_idxA;
      unsigned     result_idx_allocN;
      unsigned     result_idx_curN;

      ssf_note_on_t* perfA;       // stored performance
      unsigned       perfN;
      unsigned       perf_idx;

      dyn_ref_tbl::handle_t dynRefH;

      unsigned track_flags;
  
    } score_follower_t;

    score_follower_t* _handleToPtr( handle_t h )
    { return handleToPtr<handle_t,score_follower_t>(h); }


    // parse the score follower parameter record
    rc_t _parse_cfg( score_follower_t* p, const object_t* cfg )
    {
      rc_t            rc                         = kOkRC;
      const char*     score_csv_fname            = nullptr;
      const object_t* dyn_ref_dict               = nullptr;
      bool            track_print_fl             = false;
      bool            track_results_backtrack_fl = false;
      
      if((rc = cfg->getv("enable_flag",      p->enableFl,
                         "score_csv_fname",  score_csv_fname,
                         "search_area_locN", p->search_area_locN,
                         "key_wnd_locN",     p->key_wnd_locN,
                         "dyn_ref",          dyn_ref_dict,
                         "track_print_fl",   track_print_fl,
                         "track_results_backtrack_fl", track_results_backtrack_fl)) != kOkRC )
      {
        rc = cwLogError(kInvalidArgRC, "Score follower argument parsing failed.");
        goto errLabel;
      }

      if((p->score_csv_fname = filesys::expandPath( score_csv_fname )) == nullptr )
      {
        rc = cwLogError(kOpFailRC,"Score follower score file expansion failed.");
        goto errLabel;
      }

      if((rc = dyn_ref_tbl::create( p->dynRefH, dyn_ref_dict )) != kOkRC )
      {
        rc = cwLogError(rc,"Dynamics reference array parse failed.");
        goto errLabel;
      }

      p->track_flags += track_print_fl ? sftrack::kPrintFl : 0;
      p->track_flags += track_results_backtrack_fl ? sftrack::kBacktrackResultsFl : 0;
      
    errLabel:
      return rc;
    }
    
    rc_t _update_midi_state( score_follower_t* p, midi_state::handle_t msH )
    {
      rc_t rc;
      for(unsigned i=0; i<p->perf_idx; ++i)
      {
        if((rc = setMidiMsg( msH, p->perfA[i].sec, i, 0, midi::kNoteOnMdId, p->perfA[i].pitch, p->perfA[i].vel )) != kOkRC )
        {
          rc = cwLogError(rc,"midi_state update failed.");
          goto errLabel;
        }
      }
      
    errLabel:
      return rc;
    }

    rc_t _destroy( score_follower_t* p)
    {
      destroy(p->dynRefH);
      mem::release(p->score_csv_fname);
      mem::release(p->perfA);
      mem::release(p->result_idxA);
      destroy(p->trackH);
      if( p->deleteScoreFl)
        destroy(p->scoreH);
      //destroy(p->measH);
      mem::release(p);
      return kOkRC;
    }

    void _score_follower_cb( void* arg, sftrack::result_t* r )
    {
      score_follower_t* p = (score_follower_t*)arg;

      //printf("%4i %4i %4i %3i %3i %4s : ", r->oLocId, r->mni, r->muid, r->flags, r->pitch, midi::midiToSciPitch( r->pitch, nullptr, 0 ));

      if( r->scEvtIdx == kInvalidIdx )
      {
        //cwLogInfo("Score Follower: MISS");
      }
      else
      {
        const sfscore::event_t* score_event;
        
        // get a pointer to the matched score event
        if((score_event = event( p->scoreH, r->scEvtIdx )) == nullptr )
        {
          cwLogError(kInvalidStateRC,"cm Score event index (%i) reported by the score follower is invalid.",r->scEvtIdx );
        }
        else
        {
          // verify that the matched event buffer has available space
          if( p->result_idx_curN >= p->result_idx_allocN )
          {
            cwLogError(kInvalidStateRC,"The score follower match id array is full.");
          }
          else
          {
            assert( score_event->index == r->scEvtIdx );

            /*

            // store the performance data in the score
            set_perf( p->scoreH, score_event->index, r->sec, r->pitch, r->vel, r->cost );
            
            perf_meas::result_t pmr = {0};

            // Call performance measurement unit
            if( perf_meas::exec( p->measH, score_event, pmr ) == kOkRC && pmr.loc != kInvalidIdx && pmr.valueA != nullptr )
            {
              double v[ perf_meas::kValCnt ];
              for(unsigned i=0; i<perf_meas::kValCnt; ++i)
                v[i] = pmr.valueA[i] == std::numeric_limits<double>::max() ? -1 : pmr.valueA[i];
              
              cwLogInfo("Section '%s' triggered loc:%i : dyn:%f even:%f tempo:%f cost:%f",
                        cwStringNullGuard(pmr.sectionLabel),
                        pmr.sectionLoc,
                        v[ perf_meas::kDynValIdx ],
                        v[ perf_meas::kEvenValIdx ],
                        v[ perf_meas::kTempoValIdx ],
                        v[ perf_meas::kMatchCostValIdx ] );
            }
            
            */
            
            
            // store a pointer to the m matched sfscore event
            p->result_idxA[ p->result_idx_curN++ ] = r->index; //score_event->index;
          }
        }
      }
    }
  }
}

cw::rc_t cw::score_follower::create( handle_t& hRef, const args_t& args )
{
  rc_t        rc        = kOkRC;
  
  if((rc = destroy(hRef)) != kOkRC )
    return rc;

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

  unsigned track_flags = 0;

  track_flags += args.trackPrintFl            ? sftrack::kPrintFl            : 0;
  track_flags += args.trackResultsBacktrackFl ? sftrack::kBacktrackResultsFl : 0;

  p->scoreH = args.scoreH;
  
  // create the score tracker
  if((rc = sftrack::create( p->trackH, args.scoreH, args.scoreWndLocN, args.midiWndLocN, track_flags, _score_follower_cb, p )) != kOkRC )
  {
    cwLogError(kOpFailRC,"The score follower create failed.");
    goto errLabel;
  }

  p->srate           = sample_rate(p->scoreH);
  p->result_idx_allocN = event_count( p->scoreH )*2;  // give plenty of extra space for the result_idxA[]
  p->result_idxA       = mem::allocZ<unsigned>(p->result_idx_allocN);

  p->perfN = event_count(p->scoreH)*2;
  p->perfA = mem::allocZ<ssf_note_on_t>( p->perfN );
  p->perf_idx = 0;
  p->enableFl = args.enableFl;
  hRef.set(p);

  
 errLabel:
  if(rc != kOkRC )
    _destroy(p);
  
  return rc;
}


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

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

  if((rc = _parse_cfg(p,cfg)) != kOkRC )
    goto errLabel;

  // create the score
  if((rc = sfscore::create( p->scoreH, p->score_csv_fname, srate, p->dynRefH )) != kOkRC )
  {
    rc = cwLogError(kOpFailRC,"The score could not be initialized from '%s'. cmRC:%i.",cwStringNullGuard(p->score_csv_fname));
    goto errLabel;    
  }

  p->deleteScoreFl = true;
  
  // create the score tracker
  if((rc = sftrack::create( p->trackH, p->scoreH, p->search_area_locN, p->key_wnd_locN, p->track_flags, _score_follower_cb, p )) != kOkRC )
  {
    cwLogError(kOpFailRC,"The score follower create failed.");
    goto errLabel;
  }
  /*
  if((rc = perf_meas::create( p->measH, p->scoreH )) != kOkRC )
  {
    cwLogError(kOpFailRC,"The perf. measure object create failed.");
    goto errLabel;    
  }
  */
  p->srate           = srate;
  p->result_idx_allocN = event_count( p->scoreH )*2;  // give plenty of extra space for the result_idxA[]
  p->result_idxA       = mem::allocZ<unsigned>(p->result_idx_allocN);

  p->perfN = event_count(p->scoreH)*2;
  p->perfA = mem::allocZ<ssf_note_on_t>( p->perfN );
  p->perf_idx = 0;

  hRef.set(p);

 errLabel:
  if( rc != kOkRC )
  {
    _destroy(p);
    cwLogError(rc,"Score follower create failed.");
  }
  
  return rc;
}
    
cw::rc_t cw::score_follower::destroy( handle_t& hRef )
{
  rc_t rc = kOkRC;
  score_follower_t* p = nullptr;
  
  if( !hRef.isValid() )
    return rc;

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

  hRef.clear();
  return rc;    
}

bool cw::score_follower::is_enabled( handle_t h )
{
  score_follower_t* p    = _handleToPtr(h);
  return p->enableFl;
}

cw::rc_t cw::score_follower::reset( handle_t h, unsigned locId )
{
  rc_t              rc   = kOkRC;
  score_follower_t* p    = _handleToPtr(h);

  if( locId != kInvalidId )
  {

    printf("SF Reset: loc:%i\n",locId);
    
    if((rc = reset( p->trackH, locId )) != kOkRC )
    {
      rc = cwLogError(rc,"The score follower reset failed.");
      goto errLabel;
    }

    /*
    if((rc = reset( p->measH, locId )) != kOkRC )
    {
      rc = cwLogError(rc,"The measurement unit reset failed.");
      goto errLabel;
    }
    */
    
    p->perf_idx = 0;
    clear_result_index_array(h);    
    clear_all_performance_data(p->scoreH);
    
  }
  
 errLabel:
  return rc;
}
    
cw::rc_t cw::score_follower::exec(  handle_t h,
                                    double   sec,
                                    unsigned smpIdx,
                                    unsigned muid,
                                    unsigned status,
                                    uint8_t  d0,
                                    uint8_t  d1,
                                    bool&    newMatchFlRef )
{
  rc_t              rc                = kOkRC;
  score_follower_t* p                 = _handleToPtr(h);
  unsigned          scLocIdx          = kInvalidIdx;
  unsigned          pre_result_idx_curN = p->result_idx_curN;

  if( !p->enableFl )
    return cwLogError(kInvalidStateRC,"The score follower is not enabled.");
  
  newMatchFlRef = false;

  // Note: pass p->perf_idx as 'muid' to the score follower
  rc = exec(  p->trackH, sec, smpIdx, p->perf_idx, status, d0, d1, &scLocIdx );
  
  switch( rc )
  {
    case kOkRC:
      newMatchFlRef = p->result_idx_curN != pre_result_idx_curN;
      //printf("NM_FL:%i\n",newMatchFlRef);
      break;
        
    case kEofRC:
      rc = cwLogInfo("Score match complete.");
      break;
        
    case kInvalidArgRC:
      rc = cwLogError(kInvalidStateRC,"Score follower state is invalid.");
      break;
        
    case kOpFailRC:
      rc = cwLogError(kOpFailRC,"The score follower failed during a resync attempt.");
      break;
        
    default:
      rc = cwLogError(rc,"The score follower failed with an the error:%i",rc);
  }

  // store note-on messages
  if( p->perf_idx < p->perfN && midi::isNoteOn(status,(unsigned)d1) )
  {
    ssf_note_on_t* pno = p->perfA + p->perf_idx;
    pno->sec     = sec;
    pno->muid    = muid;
    pno->pitch   = d0;
    pno->vel     = d1;    
    p->perf_idx += 1;
    if( p->perf_idx >= p->perfN )
      cwLogWarning("The cw score follower performance cache is full.");
  }
      
  return rc;
}

const unsigned* cw::score_follower::current_result_index_array( handle_t h, unsigned& cur_result_idx_array_cnt_ref )
{
  score_follower_t* p = _handleToPtr(h);
  cur_result_idx_array_cnt_ref = p->result_idx_curN;
  return p->result_idxA;
}

void cw::score_follower::clear_result_index_array( handle_t h )
{
  score_follower_t* p = _handleToPtr(h);
  p->result_idx_curN = 0;
}
/*
cw::rc_t cw::score_follower::cw_loc_range( handle_t h, unsigned& minLocRef, unsigned& maxLocRef )
{
  rc_t rc = kOkRC;
  score_follower_t* p = _handleToPtr(h);

  minLocRef = 0;
  maxLocRef = loc_count(p->scoreH);

  return rc;
}

bool cw::score_follower::is_loc_in_range( handle_t h, unsigned loc )
{
  rc_t rc;
  unsigned minLoc = 0;
  unsigned maxLoc = 0;
  
  if((rc = cw_loc_range(h,minLoc,maxLoc)) != kOkRC )
    return false;
  
  return minLoc <= loc && loc <= maxLoc;
}
*/   
unsigned cw::score_follower::has_stored_performance( handle_t h )
{
  score_follower_t* p = _handleToPtr(h);
  return p->perf_idx > 0 && result_count(p->trackH) > 0; 
}

cw::rc_t cw::score_follower::sync_perf_to_score( handle_t h )
{
  rc_t                     rc      = kOkRC;
  score_follower_t*        p       = _handleToPtr(h);
  unsigned                 resultN = 0;
  const sftrack::result_t* resultA = nullptr;
    
  if( !has_stored_performance(h) )
  {
    rc = cwLogError(kInvalidStateRC,"No performance to sync.");
    goto errLabel;
  }

  resultN = result_count(p->trackH);
  resultA = result_base(p->trackH);
  
  for(unsigned i=0; i<resultN; ++i)
  {
    unsigned perf_idx = resultA[i].muid;

    // the matcher result 'muid' is the perf. array index of the matching perf. record
    if( perf_idx >= p->perf_idx )
    {
      rc = cwLogError(kInvalidStateRC,"Inconsistent match to perf. map: index mismatch.");
      goto errLabel;
    }

    // verify the pitch of the matching records 
    if( p->perfA[ perf_idx ].pitch != resultA[i].pitch )
    {
      rc = cwLogError(kInvalidStateRC,"Inconsistent match to perf. map: pitch mismatch %i != %i.",p->perfA[ perf_idx ].pitch ,resultA[i].pitch);
      goto errLabel;
    }

    //assert( resultA[i].scEvtIdx == kInvalidIdx || resultA[i].scEvtIdx < p->cmLocToCwLocN );

    // if( resultA[i].scEvtIdx != kInvalidIdx )
    //    p->perfA[ perf_idx ].loc = p->cmLocToCwLocA[ resultA[i].scEvtIdx ];

    if( resultA[i].scEvtIdx != kInvalidIdx )
      p->perfA[ perf_idx ].loc = resultA[i].oLocId;
  }

 errLabel:
  return rc;
}

unsigned cw::score_follower::track_result_count( handle_t h )
{
  score_follower_t* p = _handleToPtr(h);
  return result_count(p->trackH);
}

const cw::sftrack::result_t* cw::score_follower::track_result( handle_t h )
{
  score_follower_t* p = _handleToPtr(h);
  return result_base(p->trackH);
}

unsigned cw::score_follower::perf_count( handle_t h )
{
  score_follower_t* p = _handleToPtr(h);
  return p->perf_idx;
}

const cw::score_follower::ssf_note_on_t* cw::score_follower::perf_base( handle_t h )
{
  score_follower_t* p = _handleToPtr(h);
  return p->perfA;
}

cw::rc_t cw::score_follower::write_svg_file( handle_t h, const char* out_fname, bool show_muid_fl )
{
  score_follower_t* p = _handleToPtr(h);

  return svgScoreFollowWrite( p->scoreH, p->trackH, p->perfA, p->perf_idx, out_fname, show_muid_fl );
}

void cw::score_follower::score_report( handle_t h, const char* out_fname )
{
  score_follower_t* p = _handleToPtr(h);
  report(p->scoreH,out_fname);
}

cw::rc_t cw::score_follower::midi_state_rt_report( handle_t h, const char* out_fname )
{
  score_follower_t*    p     = _handleToPtr(h);
  midi_state::config_t msCfg = midi_state::default_config();
  rc_t                 rc    = kOkRC;
  midi_state::handle_t msH;
  
  if((rc = midi_state::create(msH,nullptr,nullptr,&msCfg)) != kOkRC )
  {
    rc = cwLogError(rc,"midi_state create failed.");
    goto errLabel;
  }

  if((rc = _update_midi_state(p,msH)) != kOkRC )
    goto errLabel;    

  if((rc = report_events(msH,out_fname)) != kOkRC )
    goto errLabel;

 errLabel:
  if( rc != kOkRC )
    cwLogError(rc,"Score follower midi_state_rt_report() failed.");
  
  midi_state::destroy(msH);
  return rc;
}