#include <math.h>

unsigned int Massine[8000];

typedef union{
int ch1_ch2;
char ch[2];    
}chn;

void  sinetest(void)
{    
    float ampvol_ch1  = 65;  
    float period_ch1   = 20;
//-----------------------------------------
    float ampvol_ch2  = 45;  
    float period_ch2   = 30;  
//-----------------------------------------  
    float pi   = 3.14;
    int index  = 8000;
    int i      = 0;
//-----------------------------------------
    chn channel;
    
      for(i=0; i<index; i++)
    {
            
      channel.ch[0] = 128 + (ampvol_ch1*sin(i*pi*period_ch1));  
      channel.ch[1] = 128 + (ampvol_ch2*sin(i*pi*period_ch2));
      Massine[i]      = channel.ch1_ch2;             
    }
}

#include <iostream>  
#include <fstream>
#include <math.h>

using namespace std;

typedef union {
    unsigned short data;
    struct {
        unsigned char left;
        unsigned char right;
    } chan;
} stereo_sample_t;

struct sine_param {
    float amp_vol;
    float period;
};

static unsigned char get_sine_sample(const struct sine_param *p, int i) {
    return 128u + (unsigned char)(p->amp_vol * sin(M_PI * p->period * i));
}

static int sine_test(stereo_sample_t buf[], int num_samples) {
      
    struct sine_param left_ch = {65, 20};
    struct sine_param right_ch = {45, 30};
    int i;

    for(i = 0; i < num_samples; i++) {
        buf[i].chan.left = get_sine_sample(&left_ch, i);
        buf[i].chan.right = get_sine_sample(&right_ch, i);
              
    }
}


int main(void) {  
  
ofstream File1;
File1.open("C:/MasCH1.txt");

stereo_sample_t Massine[8000] = {0};
sine_test(Massine, sizeof(Massine) / sizeof(Massine[0]));
        
for(int i = 0; i < sizeof(Massine) / sizeof(Massine[0]); i++)   {
        
    File1 << Massine[i].data << endl;
    }                          

File1.close();
}

#include <iostream>
#include <fstream>
#define _USE_MATH_DEFINES
#include <math.h>


class SinGen {
float amp;
float phase_inc;
public:
SinGen(float amplitude, float frequency, unsigned int rate = 8000)
{
amp = amplitude;
phase_inc = (float(2 * M_PI) * frequency) / rate;
}
unsigned char getSample(int i)
{
return 128u + (unsigned char)(amp * sin(phase_inc * i));
}
};

typedef union {
unsigned short data;
struct {
unsigned char left;
unsigned char right;
} chan;
} stereo_sample_t;


static void sine_test(stereo_sample_t *buf, int num_samples) {
SinGen left_ch(65, 10);
SinGen right_ch(45, 20);

for(int i = 0; i < num_samples; i++) {
buf[i].chan.left = left_ch.getSample(i);
buf[i].chan.right = right_ch.getSample(i);
}
}


int main(void) {
using namespace std;

enum {BUF_SIZE = 8000};
stereo_sample_t sine_buf[BUF_SIZE];
sine_test(sine_buf, BUF_SIZE);

ofstream SinDataFile;
SinDataFile.open("sin.txt");
for (int i = 0; i < BUF_SIZE; i++) {
SinDataFile << i << '\t';
SinDataFile << (unsigned)sine_buf[i].chan.left << '\t' << (unsigned)sine_buf[i].chan.right;
SinDataFile << endl;
}

SinDataFile.close();
return 0;
}