//
//  Oscilloscope.cpp
//  interface
//
//  Created by Philip on 1/28/13.
//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//

#include "Oscilloscope.h"

#include "InterfaceConfig.h"
#include <limits>
#include <cstring>
#include <algorithm>

//  Reimplemented 4/26/13 (tosh) - don't blame Philip for bugs

using namespace std;

namespace { // everything in here only exists while compiling this .cpp file

    // one sample buffer per channel
    unsigned const N_SAMPLES_ALLOC = Oscilloscope::MAX_SAMPLES * Oscilloscope::MAX_CHANNELS;

    // adding an x-coordinate yields twice the amount of vertices
    unsigned const MAX_COORDS = Oscilloscope::MAX_SAMPLES * 2; 
    unsigned const N_COORDS_ALLOC = MAX_COORDS * Oscilloscope::MAX_CHANNELS;
    
    unsigned const N_ALLOC_TOTAL = N_SAMPLES_ALLOC + N_COORDS_ALLOC;
}


Oscilloscope::Oscilloscope(int w, int h, bool isEnabled) : 
    _valWidth(w), _valHeight(h), 
    _arrSamples(0l), _arrVertices(0l), 
    _valLowpass(0.4f), _valDownsample(3),
    enabled(isEnabled), inputPaused(false) {
    
    // allocate enough space for the sample data and to turn it into
    // vertices and since they're all 'short', do so in one shot
    _arrSamples = new short[N_ALLOC_TOTAL];
    memset(_arrSamples, 0, N_ALLOC_TOTAL * sizeof(short));
    _arrVertices = _arrSamples + N_SAMPLES_ALLOC;

    // initialize write positions
    for (unsigned ch = 0; ch < MAX_CHANNELS; ++ch) {
        _arrWritePos[ch] = MAX_SAMPLES * ch;
    }
}

Oscilloscope::~Oscilloscope() {

    delete[] _arrSamples;
}

void Oscilloscope::addSamples(unsigned ch, short const* data, unsigned n) {

    if (! enabled || inputPaused) {
        return;
    }
    
    unsigned baseOffs = MAX_SAMPLES * ch;
    unsigned endOffs = baseOffs + MAX_SAMPLES;
        
    unsigned writePos = _arrWritePos[ch];
    unsigned newWritePos = writePos + n;

    unsigned n2 = 0;
    if (newWritePos >= endOffs) {
        n2 = newWritePos - endOffs;
        newWritePos = baseOffs + n2;
        n -= n2;
    }
        
    memcpy(_arrSamples + writePos, data, n * sizeof(short));
    if (n2 > 0) {
        memcpy(_arrSamples + baseOffs, data + n, n2 * sizeof(short));
    }
    
    _arrWritePos[ch] = newWritePos;
}
        
void Oscilloscope::render() {

    if (! enabled) {
        return;
    }
    
    // expand data to vertex data, now
    int lowpass = -int(std::numeric_limits<short>::min()) * _valLowpass;
    unsigned downsample = _valDownsample;
    // keep half of the buffer for writing and ensure an even vertex count
    unsigned usedWidth = min(_valWidth, MAX_SAMPLES / (downsample * 2)) & ~1u;
    unsigned usedSamples = usedWidth * downsample;
    
    for (unsigned ch = 0; ch < MAX_CHANNELS; ++ch) {
 
        short const* basePtr = _arrSamples + MAX_SAMPLES * ch;
        short const* endPtr = basePtr + MAX_SAMPLES;
        short const* inPtr = _arrSamples + _arrWritePos[ch];
        short* outPtr = _arrVertices + MAX_COORDS * ch;
        int sample = 0, x = usedWidth;
        for (int i = int(usedSamples); --i >= 0 ;) {

            if (inPtr == basePtr) {
                inPtr = endPtr;
            }
            sample += ((*--inPtr - sample) * lowpass) >> 15;                    
            if (i % downsample == 0) {
                *outPtr++ = short(--x);
                *outPtr++ = short(sample);
            }
        }
    } 
    
    glPushMatrix();
    glTranslatef(0.0f, _valHeight / 2.0f, 0.0f);
    glScaled(1.0f, _valHeight / 32767.0f, 1.0f);
    glVertexPointer(2, GL_SHORT, 0, _arrVertices);
    glEnableClientState(GL_VERTEX_ARRAY);
    glColor3f(1.0f, 1.0f, 1.0f);
    glDrawArrays(GL_LINES, MAX_SAMPLES * 0, usedWidth);
    glColor3f(0.0f, 1.0f ,1.0f);
    glDrawArrays(GL_LINES, MAX_SAMPLES * 1, usedWidth);
    glColor3f(1.0f, 1.0f ,0.0f);
    glDrawArrays(GL_LINES, MAX_SAMPLES * 2, usedWidth);
    glDisableClientState(GL_VERTEX_ARRAY);
    glPopMatrix();
}