新增通道参数拷贝功能

chenlh

2026-01-20 fe4d335b54ede7a47fd4bcf5c228fb427cbcc8c9

 src/messageproc.cpp

@@ -1,7 +1,7 @@
/*
 * messageproc.c
 *
 *  Created on: 2021年11月1日
 *  Created on: 2021年11月1日
 *      Author: graydon
 */
#include <string.h>
@@ -10,7 +10,7 @@
#include "messageproc.h"
#include "../drv/spi.h"
#include "../drv/gpio.h"
#include "../drv/memory.h"

#include "F2F.h"
#include "ModuleProAPI.h"
#include "tg/tg_adapter.h"
@@ -34,9 +34,44 @@

uvoid Message::ReportDspStatus(MSG* pmsg)
{
   s32 size = dsp_status_q.get_device_status_ptr(pmsg->data,MSG_DATA_LEN);
   s32 size = dsp_status_q.get_device_status_ptr(pmsg->data, MSG_DATA_LEN);
   if(size > 0) {
      pmsg->Enc(MsgType::MSG_DSP_STATUS_REPORT, 0, size);
      txQueue->Push(*pmsg);
   }
}

uvoid Message::ReportLevel(MSG* pmsg)
{
   int i;
   int data_len;

   ToB* tob = ToB::GetInstance();
   u16 LevelCnt = tob->GetLevels(Levels, levels_max_len);   //1688 levels
   u32 msgLen = LevelCnt * sizeof(*Levels);
   int Packegs = (msgLen+MSG_DATA_LEN-1)/MSG_DATA_LEN;

   pmsg->magic = 0x5aa5;
//   pmsg->dataLen = LevelCnt;
   pmsg->totalPkts = Packegs;
//   pmsg->pktNo = 1;
   pmsg->msgType = MSG_GET_LEVEL;
   pmsg->msgID = LevelCnt;

   // Split packeg
   for(i=0; i<Packegs; i++){
      if(i == Packegs-1){
         data_len = msgLen - i * MSG_DATA_LEN;
      }
      else{
         data_len = MSG_DATA_LEN;
      }

      memcpy(pmsg->data, Levels + i * MSG_DATA_LEN / sizeof(*Levels), data_len);
      pmsg->dataLen = data_len;
      pmsg->pktNo = i;

      pmsg->Enc(MsgType::MSG_GET_LEVEL, 0, data_len);
      txQueue->Push(*pmsg);
   }
}
@@ -56,19 +91,20 @@

   if(tob != NULL && pmsg->pktNo == pmsg->totalPkts - 1) {
      VarState& var = VarState::GetInstance();
      u32 type = tob->GetModuleType(ptr->mid);
//      u32 type = tob->GetModuleType(ptr->mid);
      s32 data_num = (pmsg->totalPkts-1)*MSG_DATA_LEN+pmsg->dataLen;

      s16* data = (s16*)(ptr + 1);

      data_num = (data_num - sizeof(struct ParamCtrl))/sizeof(s16);

      ptr->mid = var.pscene->get_module_id(ptr->mid, type, ptr->cmd) ;
      data_num = (data_num - sizeof(struct ParamCtrl)) / sizeof(s16);
//      ptr->mid = var.pscene->get_module_id(ptr->mid, type, ptr->cmd) ;
//      dbg_printf("mID:%d pID:%d val[0]:%d val[1]:%d\n",ptr->mid, ptr->cmd, data[0], data[1]);
      tob->toCtrl(ptr->mid, ptr->cmd, data, data_num);
   }

   return 0;
}


s32 Message::PresetProcess(MSG* pmsg)
{
@@ -79,12 +115,15 @@
      sram_free(SRAM_DDR, bin);
      bin = NULL;
   }

   if(pmsg->pktNo == 0 && bin == NULL) {
      bin = (u8*)sram_malloc(SRAM_DDR, mem_any ,pmsg->totalPkts*MSG_DATA_LEN);
      bin = (u8*)sram_malloc(SRAM_DDR, mem_any, pmsg->totalPkts*MSG_DATA_LEN);
   }
   if(bin == NULL) return -1;
//   dbg_printf("No:%d len %d\n", pmsg->pktNo,pmsg->dataLen);
   var.TopoLoading = utrue;
   memcpy(bin+pmsg->pktNo*MSG_DATA_LEN, pmsg->data , pmsg->dataLen);

   if(pmsg->pktNo == pmsg->totalPkts -1) {
      u32 size = (pmsg->totalPkts -1)*MSG_DATA_LEN+pmsg->dataLen;

@@ -100,21 +139,22 @@
            var.TopoStatus = PRESET_STA::PRESET_ERR;
         }
         else if(tob){
            s8* content = (s8*)sram_malloc(SRAM_DDR, mem_any ,16*1024);
            int preset_size = sizeof(tag_parameters); // 45128 + sizeof(tag_fir) * MAX_OUTPUT_NUM;    // size + FIR
            u8* content = (u8*)sram_malloc(SRAM_DDR, mem_any, preset_size);
            s32 size ;

            tob->toClear();

            var.pscene->update_module();
            size = var.pscene->convert_to_bin(content);

            tob->toClear();
            tob->toAnalysis(bin, size);
            tob->toAnalysis(content, size);

            sram_free(SRAM_DDR, content);
            var.TopoStatus = PRESET_STA::PRESET_DONE;
         }
      }
      sram_free(SRAM_DDR, bin); bin = NULL;
      var.TopoLoading =0 ;
      var.TopoLoading = ufalse ;
   }

   return 0;
@@ -122,34 +162,36 @@

s32 Message::HandshakeMessageProcess(MSG* pmsg)
{
//   s8 usb_rx_ch=2, usb_tx_ch=2;
   VarState& var = VarState::GetInstance();

   ptag_device_config device_config = (ptag_device_config)pmsg->data;
   struct DSPConfig dspconfig ;

   if(var.HandShakeSuccesful == ufalse) {
      //可以根据ptag_device_config.hardware_type动态适配型号.
      //可以根据ptag_device_config.hardware_type动态适配型号.
      if(var.pscene){
         delete var.pscene;
         var.pscene = NULL;
      }

      hw_adapter_t* _adapter = new tg_hw_adapter_t(device_config->dual_dsp,device_config->dsp_index
                     ,device_config->local_rx_num,device_config->local_tx_num
                     ,device_config->dante_rx_num,device_config->dante_tx_num);
      var.pscene = new tgScene(_adapter);
//      param_init(device_config);
      hw_adapter_t* _adapter = new tg_hw_adapter_t(device_config->dual_dsp, device_config->dsp_index
                     ,device_config->local_rx_num, device_config->local_tx_num
                     ,device_config->dante_rx_num, device_config->dante_tx_num);
      var.pscene = new(SRAM_DDR) tgScene(_adapter);

      _adapter->config_board(&dspconfig);
      new(SRAM_DDR) ToB(device_config->dual_dsp, device_config->dsp_index);

      SAMPLE_NUM = dspconfig.mSampleNum;
      var.master_intr = dspconfig.mIntrNo;
      var.g_level_report_interval = LEVEL_REPORT_TIME(dspconfig.mLevelReportInt);

      ModuleLeveldBUSetting(dspconfig.mConvertUnit);
      //Config(conf);
      RouteConfig(dspconfig.routes,dspconfig.mRouteNum);
      RouteConfig(dspconfig.routes, dspconfig.mRouteNum);
      SRCsConfig(0 , &dspconfig.srcs[0]);
      SRCsConfig(1 , &dspconfig.srcs[4]);
      SRCsConfig(1 , &dspconfig.srcs[1]);
      PCGsConfig(dspconfig.pcgs);
      SportsConfig(dspconfig.sports);
      //LinportConfig(dspconfig.linkport);
@@ -158,6 +200,128 @@
   }

   Send(MsgType::MSG_ACK_REQ, 0 , 0);
//   dbg_printf("HandShake OK\n");
   return 0;
}

// section equal - ret:1
// section not equal - ret:0
bool decide_modu_type_equal(ptag_module pmodu, s16 dst_ch, s16 src_ch)
{
   bool ret = 0;
   if (pmodu[dst_ch].proc_type == pmodu[src_ch].proc_type) {
      if (PROC_EQ == pmodu[dst_ch].proc_type) {
         ptag_eq proc_eq = (ptag_eq)&pmodu[dst_ch].proc_ins;
         u16 section_dst = proc_eq->nsection;
         proc_eq = (ptag_eq)&pmodu[src_ch].proc_ins;
         u16 section_src = proc_eq->nsection;
         if (section_src == section_dst)
            ret = 1;
      }
      else if (PROC_GEQ == pmodu[dst_ch].proc_type) {
         ptag_geq proc_geq = (ptag_geq)&pmodu[dst_ch].proc_ins;
         u16 section_dst = proc_geq->nsections;
         proc_geq = (ptag_geq)&pmodu[src_ch].proc_ins;
         u16 section_src = proc_geq->nsections;
         if (section_src == section_dst)
            ret = 1;
      }
      else
         ret = 1;
   }
   return ret;
}

s32 Message::ChannelParamCopy(MSG* pmag)
{
   s32 len = 0;
   ptag_ch_param_copy ch_copy = (ptag_ch_param_copy)pmag->data;
   VarState& var = VarState::GetInstance();
   void* params_ptr = var.pscene->get_parameters();
   if (params_ptr == nullptr) {
      return -1;
   }
   ptag_parameters params = static_cast<ptag_parameters>(params_ptr);
   ToB* tob = ToB::GetInstance();
   param_ctrl_t* paramset = tob->GetParamCtrl();
   s32** chin_mid = var.pscene->get_chin_mid();
   s32** chout_mid = var.pscene->get_chout_mid();
   tg_param_ctrl_t paramctrl;

   s32 max_ch = ch_copy->bOutput ? var.pscene->get_output_num() : var.pscene->get_input_num();
   if (ch_copy->src_ch_index >= max_ch || ch_copy->dst_ch_index >= max_ch || ch_copy->src_ch_index < 0 || ch_copy->dst_ch_index < 0) {
      dbg_printf("ch %s copy channel index error\n",  ch_copy->bOutput ? "out" : "in");
      return false;
   }

   if (!ch_copy->bOutput) {
      memcpy(&params->input.input[ch_copy->dst_ch_index], &params->input.input[ch_copy->src_ch_index], sizeof(params->input.input[0]));
      IModule* m = tob->GetModule(chin_mid[ch_copy->dst_ch_index][0]);   // [ch_idx][0] is the input type
      ParamCtrl_fn paramEntry = paramset->GetParamEntry(PROC_INPUT);
      paramEntry(m, (uvoid*)&params->input, len);

      ptag_module inmod_params[5] = {params->in1, params->in2, params->in3, params->in4, params->in5};
      for (s32 i = 0; i < 5; i++) {
         if (paramctrl.decide_modu_type_equal(static_cast<ptag_module>(inmod_params[i]), ch_copy->dst_ch_index, ch_copy->src_ch_index)) {   // 1
            memcpy(&inmod_params[i][ch_copy->dst_ch_index], &inmod_params[i][ch_copy->src_ch_index], sizeof(tag_module));
         }
         else {
            dbg_printf("ch dst module in%d type != src.\n", i+1);
            continue;
         }

         paramEntry = paramset->GetParamEntry(inmod_params[i][ch_copy->dst_ch_index].proc_type);
         if(paramEntry == NULL) {
            dbg_printf("paramEntry is NULL!\n");
            return -1;
         }
         m = tob->GetModule(chin_mid[ch_copy->dst_ch_index][i + 1]);
         u32 result = paramEntry(m, (uvoid*)&inmod_params[i][ch_copy->dst_ch_index].proc_ins, len);
      }
   }
   else {
      memcpy(&params->output.output[ch_copy->dst_ch_index], &params->output.output[ch_copy->src_ch_index], sizeof(params->output.output[0]));
      IModule* m = tob->GetModule(chout_mid[ch_copy->dst_ch_index][0]);   // [ch_idx][0] is the output type
      ParamCtrl_fn paramEntry = paramset->GetParamEntry(PROC_OUTPUT);
      paramEntry(m, (uvoid*)&params->output, len);

      ptag_module outmod_params[3] = {params->out1, params->out3, params->out4};
      for (s32 i = 0; i < 3; i++) {
         if (paramctrl.decide_modu_type_equal(static_cast<ptag_module>(outmod_params[i]), ch_copy->dst_ch_index, ch_copy->src_ch_index)) {   // 2
            memcpy(&outmod_params[i][ch_copy->dst_ch_index], &outmod_params[i][ch_copy->src_ch_index], sizeof(tag_module));
         }
         else {
            dbg_printf("ch dst module out%d type != src.\n", i+1);
            continue;
         }

         paramEntry = paramset->GetParamEntry(outmod_params[i][ch_copy->dst_ch_index].proc_type);
         if(paramEntry == NULL) {
            dbg_printf("paramEntry is NULL!\n");
            return -1;
         }
         m = tob->GetModule(chout_mid[ch_copy->dst_ch_index][(0==i) ? (i+1) : (i+2)]);
         u32 result = paramEntry(m, (uvoid*)&outmod_params[i][ch_copy->dst_ch_index].proc_ins, len);
//         printf("dst p adr:0x%x\n", (uvoid*)&outmod_params[i][ch_copy->dst_ch_index]);
      }

      ptag_module_fir outmod2_param = params->out2;
      if (paramctrl.decide_modu_type_equal(static_cast<ptag_module_fir>(outmod2_param), ch_copy->dst_ch_index, ch_copy->src_ch_index)) {   // 3
         memcpy(&outmod2_param[ch_copy->dst_ch_index], &outmod2_param[ch_copy->src_ch_index], sizeof(tag_module_fir));
      }
      else {
         dbg_printf("ch dst module out2 type != src.\n");
         return -1;
      }

      paramEntry = paramset->GetParamEntry(outmod2_param[ch_copy->dst_ch_index].proc_type);
      if(paramEntry == NULL) {
         dbg_printf("paramEntry is NULL!\n");
         return -1;
      }
      m = tob->GetModule(chout_mid[ch_copy->dst_ch_index][2]);
      u32 result = paramEntry(m, (uvoid*)&outmod2_param[ch_copy->dst_ch_index].proc_ins, len);
   }

   return 0;
}
@@ -166,7 +330,7 @@
{
   extern ubool  systemMute;
   if(pmsg->magic != 0x5aa5) {
      //printf("magic error.\n");
//      dbg_printf("magic error.\n");
      return -1;
   }

@@ -175,6 +339,7 @@
      ParamCtrl(pmsg);
      break;
   case MsgType::MSG_GET_LEVEL:
      ReportLevel(pmsg);
      break;
   case MsgType::MSG_PARAM_CONFIG:
   case MsgType::MSG_PARAM_COMPLETED:
@@ -182,6 +347,9 @@
      break;
   case MsgType::MSG_ACK_REQ:
      HandshakeMessageProcess(pmsg);
      break;
   case MsgType::MSG_CHANNEL_COPY_REQ:
      ChannelParamCopy(pmsg);
      break;
   default:
      break;
@@ -195,6 +363,14 @@
uvoid Message::Proc()
{
   u32 status = 0;
//   static bool bSetOk = 0;

//   MSG* p = (MSG*)SPI_Rx_BUFFER;
//   if (0 == bSetOk) {
//      HandshakeMessageProcess(p);   //virtual communication
//      PresetProcess(p);
//      bSetOk = 1;
//   }

   if(SPIRxDone) {
      RxMessageHandler((MSG*)SPI_Rx_BUFFER);
@@ -207,6 +383,6 @@
         GPIO_SetOutPut(GPIOA, GPIO_Pin12, GPIO_HIGH);
      }
      SPI2_SetTransMode(SPIStatus::SPI_TRX);
      GPIO_SetOutPut(GPIOA, GPIO_Pin13, GPIO_HIGH);
      GPIO_SetOutPut(GPIOB, GPIO_Pin5, GPIO_HIGH);
   }
}