* apps/audioutils/fmsynth/fmsynth_op.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
* Included Files
****************************************************************************/
#include <stdlib.h>
#include <audioutils/fmsynth_op.h>
* Pre-processor Definitions
****************************************************************************/
#define PHASE_ADJUST(th) \
(((th) < 0 ? (FMSYNTH_PI) - (th) : (th)) % (FMSYNTH_PI * 2))
* Private Data
****************************************************************************/
static const short s_sintbl[] =
{
0xff37,
0x0000, 0x00c9, 0x0192, 0x025b,
0x0324, 0x03ed, 0x04b6, 0x057e,
0x0647, 0x0710, 0x07d9, 0x08a1,
0x096a, 0x0a32, 0x0afb, 0x0bc3,
0x0c8b, 0x0d53, 0x0e1b, 0x0ee3,
0x0fab, 0x1072, 0x1139, 0x1200,
0x12c7, 0x138e, 0x1455, 0x151b,
0x15e1, 0x16a7, 0x176d, 0x1833,
0x18f8, 0x19bd, 0x1a82, 0x1b46,
0x1c0b, 0x1ccf, 0x1d93, 0x1e56,
0x1f19, 0x1fdc, 0x209f, 0x2161,
0x2223, 0x22e4, 0x23a6, 0x2467,
0x2527, 0x25e7, 0x26a7, 0x2767,
0x2826, 0x28e5, 0x29a3, 0x2a61,
0x2b1e, 0x2bdb, 0x2c98, 0x2d54,
0x2e10, 0x2ecc, 0x2f86, 0x3041,
0x30fb, 0x31b4, 0x326d, 0x3326,
0x33de, 0x3496, 0x354d, 0x3603,
0x36b9, 0x376f, 0x3824, 0x38d8,
0x398c, 0x3a3f, 0x3af2, 0x3ba4,
0x3c56, 0x3d07, 0x3db7, 0x3e67,
0x3f16, 0x3fc5, 0x4073, 0x4120,
0x41cd, 0x4279, 0x4325, 0x43d0,
0x447a, 0x4523, 0x45cc, 0x4674,
0x471c, 0x47c3, 0x4869, 0x490e,
0x49b3, 0x4a57, 0x4afa, 0x4b9d,
0x4c3f, 0x4ce0, 0x4d80, 0x4e20,
0x4ebf, 0x4f5d, 0x4ffa, 0x5097,
0x5133, 0x51ce, 0x5268, 0x5301,
0x539a, 0x5432, 0x54c9, 0x555f,
0x55f4, 0x5689, 0x571d, 0x57b0,
0x5842, 0x58d3, 0x5963, 0x59f3,
0x5a81, 0x5b0f, 0x5b9c, 0x5c28,
0x5cb3, 0x5d3d, 0x5dc6, 0x5e4f,
0x5ed6, 0x5f5d, 0x5fe2, 0x6067,
0x60eb, 0x616e, 0x61f0, 0x6271,
0x62f1, 0x6370, 0x63ee, 0x646b,
0x64e7, 0x6562, 0x65dd, 0x6656,
0x66ce, 0x6745, 0x67bc, 0x6831,
0x68a5, 0x6919, 0x698b, 0x69fc,
0x6a6c, 0x6adb, 0x6b4a, 0x6bb7,
0x6c23, 0x6c8e, 0x6cf8, 0x6d61,
0x6dc9, 0x6e30, 0x6e95, 0x6efa,
0x6f5e, 0x6fc0, 0x7022, 0x7082,
0x70e1, 0x7140, 0x719d, 0x71f9,
0x7254, 0x72ae, 0x7306, 0x735e,
0x73b5, 0x740a, 0x745e, 0x74b1,
0x7503, 0x7554, 0x75a4, 0x75f3,
0x7640, 0x768d, 0x76d8, 0x7722,
0x776b, 0x77b3, 0x77f9, 0x783f,
0x7883, 0x78c6, 0x7908, 0x7949,
0x7989, 0x79c7, 0x7a04, 0x7a41,
0x7a7c, 0x7ab5, 0x7aee, 0x7b25,
0x7b5c, 0x7b91, 0x7bc4, 0x7bf7,
0x7c29, 0x7c59, 0x7c88, 0x7cb6,
0x7ce2, 0x7d0e, 0x7d38, 0x7d61,
0x7d89, 0x7db0, 0x7dd5, 0x7df9,
0x7e1c, 0x7e3e, 0x7e5e, 0x7e7e,
0x7e9c, 0x7eb9, 0x7ed4, 0x7eef,
0x7f08, 0x7f20, 0x7f37, 0x7f4c,
0x7f61, 0x7f74, 0x7f86, 0x7f96,
0x7fa6, 0x7fb4, 0x7fc1, 0x7fcd,
0x7fd7, 0x7fe0, 0x7fe8, 0x7fef,
0x7ff5, 0x7ff9, 0x7ffc, 0x7ffe,
0x7fff,
};
static int local_fs;
* Private Functions
****************************************************************************/
* name: pseudo_sin256
****************************************************************************/
static int pseudo_sin256(int theta)
{
int short_sin;
int rest;
int phase;
int tblidx;
theta = PHASE_ADJUST(theta);
rest = theta & 0x7f;
phase = theta / (FMSYNTH_PI / 2);
tblidx = (theta % (FMSYNTH_PI / 2)) >> 7;
if (phase & 0x01)
{
tblidx = 257 - tblidx;
short_sin = s_sintbl[tblidx];
short_sin = short_sin
+ (((s_sintbl[tblidx - 1] - short_sin) * rest) >> 7);
}
else
{
short_sin = s_sintbl[tblidx + 1];
short_sin = short_sin
+ (((s_sintbl[tblidx + 2] - short_sin) * rest) >> 7);
}
return phase & 0x02 ? -short_sin : short_sin;
}
* name: triangle_wave
****************************************************************************/
static int triangle_wave(int theta)
{
int ret = 0;
int phase;
int offset;
int slope;
theta = PHASE_ADJUST(theta);
phase = theta / (FMSYNTH_PI / 2);
offset = theta % (FMSYNTH_PI / 2);
switch (phase)
{
case 0:
ret = 0;
slope = SHRT_MAX;
break;
case 1:
ret = SHRT_MAX;
slope = -SHRT_MAX;
break;
case 2:
ret = 0;
slope = -SHRT_MAX;
break;
case 3:
ret = -SHRT_MAX;
slope = SHRT_MAX;
break;
default:
ret = 0;
slope = SHRT_MAX;
break;
}
return ret + ((slope * offset) >> 15);
}
* name: sawtooth_wave
****************************************************************************/
static int sawtooth_wave(int theta)
{
theta = PHASE_ADJUST(theta);
return (theta >> 1) - SHRT_MAX;
}
* name: square_wave
****************************************************************************/
static int square_wave(int theta)
{
theta = PHASE_ADJUST(theta);
return theta < FMSYNTH_PI ? SHRT_MAX : -SHRT_MAX;
}
* name: update_parameters
****************************************************************************/
static void update_parameters(FAR fmsynth_op_t *op)
{
if (local_fs != 0)
{
op->delta_phase = 2 * FMSYNTH_PI * op->sound_freq * op->freq_rate
/ (float)local_fs;
}
else
{
op->delta_phase = 0.f;
}
}
* Public Functions
****************************************************************************/
* name: fmsynthop_set_samplerate
****************************************************************************/
int fmsynthop_set_samplerate(int fs)
{
if (fs < 0)
{
return ERROR;
}
local_fs = fs;
return OK;
}
* name: create_fmsynthop
****************************************************************************/
FAR fmsynth_op_t *create_fmsynthop(FAR fmsynth_op_t *op,
FAR fmsynth_eg_t *eg)
{
if (op)
{
op->eg = eg;
op->own_allocate = 0;
op->wavegen = NULL;
op->cascadeop = NULL;
op->parallelop = NULL;
op->feedback_ref = NULL;
op->feedback_val = 0;
op->feedbackrate = 0;
op->last_sigval = 0;
op->freq_rate = 1.f;
op->sound_freq = 0.f;
op->delta_phase = 0.f;
op->current_phase = 0.f;
}
return op;
}
* name: fmsynthop_create
****************************************************************************/
FAR fmsynth_op_t *fmsynthop_create(void)
{
FAR fmsynth_op_t *ret;
ret = (FAR fmsynth_op_t *)malloc(sizeof(fmsynth_op_t));
if (ret)
{
ret->eg = fmsyntheg_create();
if (!ret->eg)
{
free(ret);
return NULL;
}
create_fmsynthop(ret, ret->eg);
ret->own_allocate = 1;
}
return ret;
}
* name: fmsynthop_delete
****************************************************************************/
void fmsynthop_delete(FAR fmsynth_op_t *op)
{
if (op != NULL && op->own_allocate == 1)
{
if (op->eg)
{
fmsyntheg_delete(op->eg);
}
free(op);
}
}
* name: fmsynthop_select_opfunc
****************************************************************************/
int fmsynthop_select_opfunc(FAR fmsynth_op_t *op, int type)
{
int ret = ERROR;
if (op != NULL)
{
switch (type)
{
case FMSYNTH_OPFUNC_SIN:
op->wavegen = pseudo_sin256;
ret = OK;
break;
case FMSYNTH_OPFUNC_TRIANGLE:
op->wavegen = triangle_wave;
ret = OK;
break;
case FMSYNTH_OPFUNC_SAWTOOTH:
op->wavegen = sawtooth_wave;
ret = OK;
break;
case FMSYNTH_OPFUNC_SQUARE:
op->wavegen = square_wave;
ret = OK;
break;
}
}
return ret;
}
* name: fmsynthop_set_envelope
****************************************************************************/
int fmsynthop_set_envelope(FAR fmsynth_op_t *op,
FAR fmsynth_eglevels_t *levels)
{
if (local_fs >= 0 && op && levels)
{
return fmsyntheg_set_param(op->eg, local_fs, levels);
}
return ERROR;
}
* name: fmsynthop_cascade_subop
****************************************************************************/
int fmsynthop_cascade_subop(FAR fmsynth_op_t *op,
FAR fmsynth_op_t *subop)
{
FAR fmsynth_op_t *tmp;
if (!op || !subop)
{
return ERROR;
}
for (tmp = op; tmp->cascadeop; tmp = tmp->cascadeop);
tmp->cascadeop = subop;
return OK;
}
* name: fmsynthop_parallel_subop
****************************************************************************/
int fmsynthop_parallel_subop(FAR fmsynth_op_t *op,
FAR fmsynth_op_t *subop)
{
FAR fmsynth_op_t *tmp;
if (!op || !subop)
{
return ERROR;
}
for (tmp = op; tmp->parallelop; tmp = tmp->parallelop);
tmp->parallelop = subop;
return OK;
}
* name: fmsynthop_bind_feedback
****************************************************************************/
int fmsynthop_bind_feedback(FAR fmsynth_op_t *op,
FAR fmsynth_op_t *subop, float ratio)
{
if (!op || !subop)
{
return ERROR;
}
op->feedbackrate = (int)((float)FMSYNTH_MAX_EGLEVEL * ratio);
op->feedback_ref = &subop->last_sigval;
return OK;
}
* name: fmsynthop_update_feedback
****************************************************************************/
int fmsynthop_update_feedback(FAR fmsynth_op_t *op)
{
FAR fmsynth_op_t *tmp;
for (tmp = op->cascadeop; tmp != NULL; tmp = tmp->parallelop)
{
fmsynthop_update_feedback(tmp);
}
if (op->feedback_ref)
{
op->feedback_val = *op->feedback_ref * op->feedbackrate
/ FMSYNTH_MAX_EGLEVEL;
}
return OK;
}
* name: fmsynthop_set_soundfreq
****************************************************************************/
void fmsynthop_set_soundfreq(FAR fmsynth_op_t *op, float freq)
{
FAR fmsynth_op_t *tmp;
op->sound_freq = freq;
update_parameters(op);
for (tmp = op->cascadeop; tmp != NULL; tmp = tmp->parallelop)
{
fmsynthop_set_soundfreq(tmp, freq);
}
}
* name: fmsynthop_set_soundfreqrate
****************************************************************************/
void fmsynthop_set_soundfreqrate(FAR fmsynth_op_t *op, float rate)
{
op->freq_rate = rate;
update_parameters(op);
}
* name: fmsynthop_start
****************************************************************************/
void fmsynthop_start(FAR fmsynth_op_t *op)
{
FAR fmsynth_op_t *tmp;
fmsyntheg_start(op->eg);
for (tmp = op->cascadeop; tmp; tmp = tmp->parallelop)
{
fmsynthop_start(tmp);
}
}
* name: fmsynthop_stop
****************************************************************************/
void fmsynthop_stop(FAR fmsynth_op_t *op)
{
FAR fmsynth_op_t *tmp;
fmsyntheg_stop(op->eg);
for (tmp = op->cascadeop; tmp; tmp = tmp->parallelop)
{
fmsynthop_stop(tmp);
}
}
* name: fmsynthop_operate
****************************************************************************/
int fmsynthop_operate(FAR fmsynth_op_t *op, int phase_time)
{
int val;
int val2;
int phase;
FAR fmsynth_op_t *subop;
op->current_phase = phase_time ? op->current_phase + op->delta_phase : 0.f;
val = (int)op->current_phase;
val2 = (val / (2 * FMSYNTH_PI));
phase = (int)val + op->feedback_val;
op->current_phase = op->current_phase - (float)(val2 * (2 * FMSYNTH_PI));
subop = op->cascadeop;
while (subop)
{
phase += fmsynthop_operate(subop, phase_time);
subop = subop->parallelop;
}
op->last_sigval = fmsyntheg_operate(op->eg) * op->wavegen(phase)
/ FMSYNTH_MAX_EGLEVEL;
return op->last_sigval;
}