ref: a4e30b9d7b1f7b647c475f67b018091ba56b7c80
dir: /korg_syro_volcasample.c/
/************************************************************************
SYRO for volca sample
***********************************************************************/
#include <stdlib.h>
#include <string.h>
#include "korg_syro_type.h"
#include "korg_syro_volcasample.h"
#include "korg_syro_func.h"
#include "korg_syro_comp.h"
#define NUM_OF_DATA_MAX (VOLCASAMPLE_NUM_OF_PATTERN + VOLCASAMPLE_NUM_OF_SAMPLE)
#define VOLCA_SAMPLE_FS 31250
#define SYRO_MANAGE_HEADER 0x47524F4B
#define ALL_INFO_SIZE 0x4000
#define BLOCK_SIZE 256
#define BLOCK_PER_SECTOR 256
#define BLOCK_PER_SUBSECTOR 16
#define SUBSECTOR_SIZE (BLOCK_SIZE * BLOCK_PER_SUBSECTOR)
#define LPF_FEEDBACK_LEVEL 0x2000
#define NUM_OF_GAP_HEADER_CYCLE 10000
#define NUM_OF_GAP_CYCLE 35
#define NUM_OF_GAP_F_CYCLE 1000
#define NUM_OF_GAP_FOOTER_CYCLE 3000
#define NUM_OF_GAP_3S_CYCLE 15000
#define NUM_OF_FRAME__GAP_HEADER (NUM_OF_GAP_HEADER_CYCLE * KORGSYRO_QAM_CYCLE)
#define NUM_OF_FRAME__GAP (NUM_OF_GAP_CYCLE * KORGSYRO_QAM_CYCLE)
#define NUM_OF_FRAME__GAP_F (NUM_OF_GAP_F_CYCLE * KORGSYRO_QAM_CYCLE)
#define NUM_OF_FRAME__GAP_3S (NUM_OF_GAP_3S_CYCLE * KORGSYRO_QAM_CYCLE)
#define NUM_OF_FRAME__GAP_FOOTER (NUM_OF_GAP_FOOTER_CYCLE * KORGSYRO_QAM_CYCLE)
#define NUM_OF_FRAME__HEADER (49 * KORGSYRO_QAM_CYCLE)
#define NUM_OF_FRAME__BLOCK (352 * KORGSYRO_QAM_CYCLE)
#define TXHEADER_STR_LEN 16
#define TXHEADER_STR "KORG SYSTEM FILE"
#define TXHEADER_DEVICE_ID 0xff0033b8 // volca sample
#define TXHEADER_BLOCK_ALL 0x01
#define TXHEADER_BLOCK_ALL_COMPRESS 0x03
#define TXHEADER_BLOCK_SAMPLE_LINER 0x10
#define TXHEADER_BLOCK_PATTERN 0x20
#define TXHEADER_BLOCK_SAMPLE_COMPRESS 0x30
typedef enum {
TaskStatus_Gap = 0,
TaskStatus_StartMark,
TaskStatus_ChannelInfo,
TaskStatus_Data,
TaskStatus_Gap_Footer,
TaskStatus_End = -1
} SyroTaskStatus;
typedef struct {
uint8_t Header[TXHEADER_STR_LEN];
uint32_t DeviceID;
uint8_t BlockCode;
uint8_t Num;
uint8_t Misc[2];
uint8_t Size[4];
uint16_t m_Reserved;
uint16_t m_Speed;
} SyroTxHeader;
typedef struct {
uint32_t Header;
uint32_t Flags;
SyroTaskStatus TaskStatus;
int TaskCount;
//---- Manage source data(all) -----
int NumOfData;
int CurData;
//---- Manage source data(this) -----
const uint8_t *pSrcData;
int DataCount;
int DataSize;
uint32_t EraseAlign;
uint32_t EraseLength;
uint32_t EraseCount;
bool IsCompData;
int CompBlockPos;
uint32_t BlockLen1st;
Endian SampleEndian;
//---- Manage output data -----
uint8_t TxBlock[BLOCK_SIZE];
int TxBlockSize;
int TxBlockPos;
uint32_t PoolData;
int PoolDataBit;
bool UseEcc;
uint32_t EccData;
bool UseCrc;
uint32_t CrcData;
SyroChannel Channel[KORGSYRO_NUM_OF_CHANNEL];
int CyclePos;
int FrameCountInCycle;
int LongGapCount; // Debug Put
} SyroManage;
typedef struct {
SyroData Data;
uint8_t *comp_buf;
uint32_t comp_size;
} SyroManageSingle;
/*-----------------------------------------------------------------------
Setup Next Data
-----------------------------------------------------------------------*/
static void SyroVolcaSample_SetupNextData(SyroManage *psm)
{
SyroManageSingle *psms;
SyroTxHeader *psth;
uint8_t block = 0;
psms = (SyroManageSingle *)(psm+1);
psms += psm->CurData;
//----- Setup Tx Header ----
psth = (SyroTxHeader *)psm->TxBlock;
memset((uint8_t *)psth, 0, sizeof(SyroTxHeader));
memcpy(psth->Header, TXHEADER_STR, TXHEADER_STR_LEN);
psth->DeviceID = TXHEADER_DEVICE_ID;
psth->Num = (uint8_t)psms->Data.Number;
psm->SampleEndian = LittleEndian;
psm->TxBlockSize = sizeof(SyroTxHeader);
psm->pSrcData = psms->Data.pData;
psm->DataSize = psms->Data.Size;
psm->DataCount = 0;
psm->IsCompData = false;
psm->CompBlockPos = 0;
psm->EraseAlign = 0;
psm->EraseLength = 0;
switch (psms->Data.DataType) {
case DataType_Sample_All:
case DataType_Sample_AllCompress:
if (psms->Data.DataType == DataType_Sample_All) {
block = TXHEADER_BLOCK_ALL;
psth->Misc[0] = 0xff;
} else {
block = TXHEADER_BLOCK_ALL_COMPRESS;
psm->pSrcData = psms->comp_buf;
psm->DataSize = psms->comp_size;
psm->IsCompData = true;
psth->Misc[0] = (uint8_t)psms->Data.Quality;
psm->BlockLen1st = ALL_INFO_SIZE;
}
if ((psm->CurData+1) < psm->NumOfData) {
block++; //----- Set continue
}
SyroFunc_SetTxSize(psth->Size, psms->Data.Size, 4);
psth->Misc[1] = 0xff;
psth->Num = 0xff;
psm->EraseAlign = (BLOCK_PER_SECTOR * BLOCK_SIZE);
psm->EraseLength = NUM_OF_GAP_3S_CYCLE;
psm->EraseCount = (psms->Data.Size + psm->EraseAlign - 1) / psm->EraseAlign;
break;
case DataType_Sample_Liner:
case DataType_Sample_Compress:
if (psms->Data.DataType == DataType_Sample_Liner) {
block = TXHEADER_BLOCK_SAMPLE_LINER;
} else {
block = TXHEADER_BLOCK_SAMPLE_COMPRESS;
psm->pSrcData = psms->comp_buf;
psm->DataSize = psms->comp_size;
psm->IsCompData = true;
psth->Misc[0] = (uint8_t)psms->Data.Quality;
psm->BlockLen1st = 0;
}
if ((psm->CurData+1) < psm->NumOfData) {
block |= 1; //----- Set continue bit
}
SyroFunc_SetTxSize(psth->Size, psms->Data.Size, 4);
psth->m_Reserved = 0xffff;
psth->m_Speed = (uint16_t)(psms->Data.Fs * 0x4000 / VOLCA_SAMPLE_FS);
psm->SampleEndian = psms->Data.SampleEndian;
psm->EraseAlign = (SUBSECTOR_SIZE - 2);
psm->EraseLength = NUM_OF_GAP_F_CYCLE;
psm->EraseCount = (psms->Data.Size + psm->EraseAlign - 1) / psm->EraseAlign;
break;
case DataType_Sample_Erase:
block = TXHEADER_BLOCK_SAMPLE_LINER;
if ((psm->CurData+1) < psm->NumOfData) {
block |= 1; //----- Set continue bit
}
psth->m_Reserved = 0xffff;
psth->m_Speed = 0x4000;
psm->pSrcData = NULL;
psm->DataSize = 0;
break;
case DataType_Pattern:
block = TXHEADER_BLOCK_PATTERN;
if ((psm->CurData+1) < psm->NumOfData) {
block |= 1; //----- Set continue bit
}
SyroFunc_SetTxSize(psth->Size, psm->DataSize, 4);
break;
default:
break;
}
psth->BlockCode = block;
psm->TaskStatus = TaskStatus_Gap;
psm->TaskCount = NUM_OF_GAP_HEADER_CYCLE;
}
/*-----------------------------------------------------------------------
Setup by TxBlock
-----------------------------------------------------------------------*/
static void SyroVolcaSample_SetupBlock(SyroManage *psm)
{
bool use_ecc;
use_ecc = (psm->TxBlockSize == BLOCK_SIZE) ? true : false;
psm->TxBlockPos = 0;
psm->TaskCount = psm->TxBlockSize;
psm->UseEcc = use_ecc;
psm->UseCrc = true;
psm->CrcData = SyroFunc_CalculateCrc16(psm->TxBlock, psm->TxBlockSize);
if (use_ecc) {
psm->EccData = SyroFunc_CalculateEcc(psm->TxBlock, psm->TxBlockSize);
}
psm->PoolData = 0xa9; // Block Start Code
psm->PoolDataBit = 8;
}
/************************************************************************
Internal Functions (Output Syro Data)
***********************************************************************/
/*-----------------------------------------------------------------------
Generate Data
ret : true if block is end.
-----------------------------------------------------------------------*/
static bool SyroVolcaSample_MakeData(SyroManage *psm, int write_page)
{
int ch, bit;
uint32_t dat;
bool data_end;
data_end = false;
//------ Supply Data/Ecc/Crc ------
if (psm->PoolDataBit < (3 * KORGSYRO_NUM_OF_CHANNEL)) {
if (psm->TaskCount) {
dat = psm->TxBlock[psm->TxBlockPos++];
bit = 8;
psm->TaskCount--;
} else if (psm->UseEcc) {
dat = psm->EccData;
bit = 24;
psm->UseEcc = false;
} else if (psm->UseCrc) {
dat = psm->CrcData;
bit = 16;
psm->UseCrc = false;
} else {
dat = 0;
bit = (3 * KORGSYRO_NUM_OF_CHANNEL) - psm->PoolDataBit;
data_end = true;
}
psm->PoolData |= (dat << psm->PoolDataBit);
psm->PoolDataBit += bit;
}
//------ Make Cycle ------
for (ch=0; ch<KORGSYRO_NUM_OF_CHANNEL; ch++) {
SyroFunc_GenerateSingleCycle(&psm->Channel[ch], write_page, (psm->PoolData & 7), true);
psm->PoolData >>= 3;
psm->PoolDataBit -= 3;
}
return data_end;
}
/*-----------------------------------------------------------------------
Nake Next Cycle
-----------------------------------------------------------------------*/
static void SyroVolcaSample_CycleHandler(SyroManage *psm)
{
int write_page;
uint32_t comp_len, org_len;
write_page = (psm->CyclePos / KORGSYRO_QAM_CYCLE) ^ 1;
switch (psm->TaskStatus) {
case TaskStatus_Gap:
SyroFunc_MakeGap(psm->Channel, write_page);
if (!(--psm->TaskCount)) {
psm->TaskStatus = TaskStatus_StartMark;
SyroVolcaSample_SetupBlock(psm);
}
break;
case TaskStatus_StartMark:
SyroFunc_MakeStartMark(psm->Channel, write_page);
psm->TaskStatus = TaskStatus_ChannelInfo;
break;
case TaskStatus_ChannelInfo:
SyroFunc_MakeChannelInfo(psm->Channel, write_page);
psm->TaskStatus = TaskStatus_Data;
break;
case TaskStatus_Data:
if (SyroVolcaSample_MakeData(psm, write_page)) {
if (psm->DataCount < psm->DataSize) {
int pos, size;
size = (psm->DataSize - psm->DataCount);
if (size >= BLOCK_SIZE) {
size = BLOCK_SIZE;
} else {
memset(psm->TxBlock, 0, BLOCK_SIZE);
}
if (psm->SampleEndian == LittleEndian) {
memcpy(psm->TxBlock, (psm->pSrcData+psm->DataCount), size);
} else {
for (pos=0; pos<size; pos+=2) {
psm->TxBlock[pos] = psm->pSrcData[psm->DataCount+pos+1];
psm->TxBlock[pos+1] = psm->pSrcData[psm->DataCount+pos];
}
}
psm->TaskStatus = TaskStatus_Gap;
psm->TaskCount = NUM_OF_GAP_CYCLE;
if (!psm->IsCompData) {
if (psm->EraseAlign && (!(psm->DataCount % psm->EraseAlign))) {
psm->TaskCount = psm->EraseLength;
}
} else {
if (psm->EraseCount && (psm->CompBlockPos < (psm->DataCount+size))) {
psm->TaskCount = psm->EraseLength;
psm->EraseCount--;
org_len = 0;
for (;;) {
if (psm->BlockLen1st) {
psm->CompBlockPos += psm->BlockLen1st;
org_len += psm->BlockLen1st;
psm->BlockLen1st = 0;
} else {
comp_len = (uint32_t)psm->pSrcData[psm->CompBlockPos+2];
comp_len <<= 8;
comp_len |= (uint32_t)psm->pSrcData[psm->CompBlockPos+3];
psm->CompBlockPos += (comp_len+6);
org_len += (VOLCASAMPLE_COMP_BLOCK_LEN * 2);
}
if ((psm->CompBlockPos >= psm->DataSize) ||
(org_len >= psm->EraseAlign))
{
break;
}
}
}
}
psm->TxBlockSize = BLOCK_SIZE;
psm->DataCount += size;
} else {
psm->CurData++;
if (psm->CurData < psm->NumOfData) {
SyroVolcaSample_SetupNextData(psm);
} else {
psm->TaskStatus = TaskStatus_Gap_Footer;
psm->TaskCount = NUM_OF_GAP_FOOTER_CYCLE;
}
}
}
break;
case TaskStatus_Gap_Footer:
SyroFunc_MakeGap(psm->Channel, write_page);
if (!(--psm->TaskCount)) {
psm->TaskStatus = TaskStatus_End;
}
break;
default: // case TaskStatus_End:
return;
}
psm->FrameCountInCycle += KORGSYRO_QAM_CYCLE;
}
/*-----------------------------------------------------------------------
Get Ch Sample
-----------------------------------------------------------------------*/
static int16_t SyroVolcaSample_GetChSample(SyroManage *psm, int ch)
{
int32_t dat;
dat = (int32_t)psm->Channel[ch].CycleSample[psm->CyclePos];
//----- LPF -----*/
dat = ((dat * (0x10000 - LPF_FEEDBACK_LEVEL)) +
(psm->Channel[ch].Lpf_z * LPF_FEEDBACK_LEVEL));
dat /= 0x10000;
psm->Channel[ch].Lpf_z = dat;
return (int16_t)dat;
}
/*-----------------------------------------------------------------------
Get Frame Size (union)
-----------------------------------------------------------------------*/
static uint32_t SyroVolcaSample_GetFrameSize(int num_of_block)
{
uint32_t size;
size = NUM_OF_FRAME__GAP_HEADER;
size += NUM_OF_FRAME__HEADER;
size += (NUM_OF_FRAME__GAP + NUM_OF_FRAME__BLOCK) * num_of_block;
return size;
}
/*-----------------------------------------------------------------------
Get Frame Size (Pattern)
-----------------------------------------------------------------------*/
static uint32_t SyroVolcaSample_GetFrameSize_Pattern(void)
{
return SyroVolcaSample_GetFrameSize((VOLCASAMPLE_PATTERN_SIZE + BLOCK_SIZE - 1) / BLOCK_SIZE);
}
/*-----------------------------------------------------------------------
Get Frame Size (Sample)
-----------------------------------------------------------------------*/
static uint32_t SyroVolcaSample_GetFrameSize_Sample(uint32_t byte_size)
{
uint32_t size;
uint32_t num_of_block;
num_of_block = (byte_size + BLOCK_SIZE - 1) / BLOCK_SIZE;
size = SyroVolcaSample_GetFrameSize(num_of_block);
num_of_block = (byte_size + SUBSECTOR_SIZE - 3) / (SUBSECTOR_SIZE - 2);
size += (NUM_OF_FRAME__GAP_F - NUM_OF_FRAME__GAP) * num_of_block;
return size;
}
/*-----------------------------------------------------------------------
Get Frame Size (Sample, Compress)
-----------------------------------------------------------------------*/
static uint32_t SyroVolcaSample_GetFrameSize_Sample_Comp(SyroData *pdata)
{
uint32_t size, comp_size;
uint32_t num_of_block;
comp_size = SyroComp_GetCompSize(
pdata->pData,
(pdata->Size / 2),
pdata->Quality,
pdata->SampleEndian
);
//----- get frame size from compressed size.
num_of_block = (comp_size + BLOCK_SIZE - 1) / BLOCK_SIZE;
size = SyroVolcaSample_GetFrameSize(num_of_block);
//----- get gap size from original size.
num_of_block = (pdata->Size + SUBSECTOR_SIZE - 3) / (SUBSECTOR_SIZE - 2);
size += (NUM_OF_FRAME__GAP_F - NUM_OF_FRAME__GAP) * num_of_block;
return size;
}
/*-----------------------------------------------------------------------
Get Frame Size (All)
-----------------------------------------------------------------------*/
static uint32_t SyroVolcaSample_GetFrameSize_All(uint32_t byte_size)
{
uint32_t size;
uint32_t num_of_block;
num_of_block = (byte_size + BLOCK_SIZE - 1) / BLOCK_SIZE;
size = SyroVolcaSample_GetFrameSize(num_of_block);
num_of_block = (num_of_block + BLOCK_PER_SECTOR - 1) / BLOCK_PER_SECTOR;
size += (NUM_OF_FRAME__GAP_3S - NUM_OF_FRAME__GAP) * num_of_block;
return size;
}
/*-----------------------------------------------------------------------
Get Frame Size (All, Comp)
-----------------------------------------------------------------------*/
static uint32_t SyroVolcaSample_GetFrameSize_AllComp(SyroData *pdata)
{
uint32_t size, comp_size;
uint32_t num_of_block;
if (pdata->Size == ALL_INFO_SIZE) {
return SyroVolcaSample_GetFrameSize_All(pdata->Size);
}
comp_size = SyroComp_GetCompSize(
(pdata->pData + ALL_INFO_SIZE),
((pdata->Size - ALL_INFO_SIZE) / 2),
pdata->Quality,
LittleEndian
);
comp_size += ALL_INFO_SIZE;
num_of_block = (comp_size + BLOCK_SIZE - 1) / BLOCK_SIZE;
size = SyroVolcaSample_GetFrameSize(num_of_block);
num_of_block = (pdata->Size + BLOCK_SIZE - 1) / BLOCK_SIZE;
num_of_block = (num_of_block + BLOCK_PER_SECTOR - 1) / BLOCK_PER_SECTOR;
size += (NUM_OF_FRAME__GAP_3S - NUM_OF_FRAME__GAP) * num_of_block;
return size;
}
/*-----------------------------------------------------------------------
free compress memory
-----------------------------------------------------------------------*/
static void SyroVolcaSample_FreeCompressMemory(SyroManage *psm)
{
int i;
SyroManageSingle *psms;
psms = (SyroManageSingle *)(psm+1);
for (i=0; i<psm->NumOfData; i++) {
if (psms->comp_buf) {
free(psms->comp_buf);
psms->comp_buf = NULL;
}
psms++;
}
}
/************************************************************************
Exteral Functions
***********************************************************************/
/*======================================================================
Syro Start
======================================================================*/
SyroStatus SyroVolcaSample_Start(SyroHandle *pHandle, SyroData *pData, int NumOfData,
uint32_t Flags, uint32_t *pNumOfSyroFrame)
{
int i;
uint32_t handle_size;
uint32_t frame_size;
uint32_t comp_org_size, comp_dest_size, comp_ofs;
uint8_t *comp_src_adr;
Endian comp_endian;
SyroManage *psm;
SyroManageSingle *psms;
//--------------------------------
//------- Parameter check --------
//--------------------------------
if ((!NumOfData) || (NumOfData >= NUM_OF_DATA_MAX)) {
return Status_IllegalParameter;
}
frame_size = 0;
for (i=0; i<NumOfData; i++) {
switch (pData[i].DataType) {
case DataType_Sample_All:
if (pData[i].Size < ALL_INFO_SIZE) {
return Status_IllegalData;
}
frame_size += SyroVolcaSample_GetFrameSize_All(pData[i].Size);
break;
case DataType_Sample_AllCompress:
if (pData[i].Size < ALL_INFO_SIZE) {
return Status_IllegalData;
}
if ((pData[i].Quality < 8) || (pData[i].Quality > 16)) {
return Status_OutOfRange_Quality;
}
frame_size += SyroVolcaSample_GetFrameSize_AllComp(&pData[i]);
break;
case DataType_Pattern:
if (pData[i].Number >= VOLCASAMPLE_NUM_OF_PATTERN) {
return Status_OutOfRange_Number;
}
frame_size += SyroVolcaSample_GetFrameSize_Pattern();
break;
case DataType_Sample_Compress:
if (pData[i].Number >= VOLCASAMPLE_NUM_OF_SAMPLE) {
return Status_OutOfRange_Number;
}
if ((pData[i].Quality < 8) || (pData[i].Quality > 16)) {
return Status_OutOfRange_Quality;
}
frame_size += SyroVolcaSample_GetFrameSize_Sample_Comp(&pData[i]);
break;
case DataType_Sample_Erase:
if (pData[i].Number >= VOLCASAMPLE_NUM_OF_SAMPLE) {
return Status_OutOfRange_Number;
}
frame_size += SyroVolcaSample_GetFrameSize_Sample(0);
break;
case DataType_Sample_Liner:
if (pData[i].Number >= VOLCASAMPLE_NUM_OF_SAMPLE) {
return Status_OutOfRange_Number;
}
frame_size += SyroVolcaSample_GetFrameSize_Sample(pData[i].Size);
break;
default:
return Status_IllegalDataType;
}
}
frame_size += NUM_OF_FRAME__GAP_FOOTER;
//-----------------------------
//------- Alloc Memory --------
//-----------------------------
handle_size = sizeof(SyroManage) + (sizeof(SyroManageSingle) * NumOfData);
psm = (SyroManage *)malloc(handle_size);
if (!psm) {
return Status_NotEnoughMemory;
}
psms = (SyroManageSingle *)(psm+1);
//----------------------
//------- Setup --------
//----------------------
memset((uint8_t *)psm, 0, handle_size);
psm->Header = SYRO_MANAGE_HEADER;
psm->Flags = Flags;
psm->NumOfData = NumOfData;
for (i=0; i<NumOfData; i++) {
psms[i].Data = pData[i];
comp_org_size = 0;
comp_ofs = 0;
comp_src_adr = 0;
comp_endian = LittleEndian;
switch (pData[i].DataType) {
case DataType_Sample_Compress:
comp_src_adr = pData[i].pData;
comp_org_size = (pData[i].Size / 2);
comp_endian = pData[i].SampleEndian;
break;
case DataType_Sample_AllCompress:
if (psms[i].Data.Size == ALL_INFO_SIZE) {
psms[i].Data.DataType = DataType_Sample_All;
break;
}
comp_ofs = ALL_INFO_SIZE;
comp_src_adr = pData[i].pData + ALL_INFO_SIZE;
comp_org_size = ((pData[i].Size - ALL_INFO_SIZE) / 2);
comp_endian = LittleEndian;
default:
break;
}
if (comp_org_size) {
comp_dest_size = SyroComp_GetCompSize(
comp_src_adr,
comp_org_size,
pData[i].Quality,
comp_endian
);
comp_dest_size = (comp_dest_size + BLOCK_SIZE - 1) & (~(BLOCK_SIZE-1));
psms[i].comp_size = (comp_dest_size + comp_ofs);
psms[i].comp_buf = malloc(comp_dest_size + comp_ofs);
if (!psms[i].comp_buf) {
SyroVolcaSample_FreeCompressMemory(psm);
free((uint8_t *)psm);
return Status_NotEnoughMemory;
};
memset(psms[i].comp_buf, 0, comp_dest_size);
if (comp_ofs) {
memcpy(psms[i].comp_buf, pData[i].pData, comp_ofs);
}
SyroComp_Comp(comp_src_adr, (psms[i].comp_buf+comp_ofs), comp_org_size,
pData[i].Quality, comp_endian);
}
}
SyroVolcaSample_SetupNextData(psm);
for (i=0; i<KORGSYRO_NUM_OF_CYCLE; i++) {
SyroVolcaSample_CycleHandler(psm);
psm->CyclePos += KORGSYRO_QAM_CYCLE;
}
psm->CyclePos = 0;
*pHandle = (SyroHandle)psm;
*pNumOfSyroFrame = frame_size;
return Status_Success;
}
/*======================================================================
Syro Get Sample
======================================================================*/
SyroStatus SyroVolcaSample_GetSample(SyroHandle Handle, int16_t *pLeft, int16_t *pRight)
{
SyroManage *psm;
psm = (SyroManage *)Handle;
if (psm->Header != SYRO_MANAGE_HEADER) {
return Status_InvalidHandle;
}
if (!psm->FrameCountInCycle) {
return Status_NoData;
}
*pLeft = SyroVolcaSample_GetChSample(psm, 0);
*pRight = SyroVolcaSample_GetChSample(psm, 1);
psm->FrameCountInCycle--;
if ((++psm->CyclePos) == KORGSYRO_NUM_OF_CYCLE_BUF) {
psm->CyclePos = 0;
}
if (!(psm->CyclePos % KORGSYRO_QAM_CYCLE)) {
SyroVolcaSample_CycleHandler(psm);
}
return Status_Success;
}
/*======================================================================
Syro End
======================================================================*/
SyroStatus SyroVolcaSample_End(SyroHandle Handle)
{
SyroManage *psm;
psm = (SyroManage *)Handle;
if (psm->Header != SYRO_MANAGE_HEADER) {
return Status_InvalidHandle;
}
SyroVolcaSample_FreeCompressMemory(psm);
free((uint8_t *)psm);
return Status_Success;
}