/**********************************************************************
Copyright (c) 1994 - 1998  Microsoft Corporation.  All Rights Reserved.

LtcDecode, Ken Greenebaum, November 1996

A generic linear timecode decoder.  Pass it 16 bit mono PCM raw audio
samples and it will decode the LTC timecode encoded therein.

This code based on the LTC description in John Ratcliff's Timecode; A user's
 guide by  (second edition)
**********************************************************************/
#include <stdio.h>
#include <wtypes.h>
#include "ltcdcode.h"


/**********************************************************************
helper function to decode raw LTC bits found in the circular bit buffer
**********************************************************************/
int
compute(int begin, int bitNumber, int numBits, bitData ringBuffer[])
{
    int value = 0;
    int count;
    int index;

    index = (begin + bitNumber) % 80;
    for(count = 0; count < numBits; count++) {
        value+= ringBuffer[index].value << count;
        index = (index+1)%80;
    }

    return(value);
}


/**********************************************************************
initialize internal state
**********************************************************************/
LTCdecoder::LTCdecoder()
{
// XXX these should all be initialy computed based on format!
_bitWidth        =    0; // this will get set at the first bit...
_verticalEpsilon = 1024;

// values to reset
_waveState       =    0; // doesn't really matter where we start it
_sampleWidth     =    0; // reset bit width
_lastBit         =    0; // must be zero so we can legaly have a one!
_onesCount       =    0; // reset the sync detector
_samplesProcessed=    0; // total number of audio samples processed
_bitsRecorded    =    0;
_bufferIndex     =    0;
_syncSample      =    0;
_validTimeCode   =    0; // no, we don't have a valid timecode, yet
}


/**********************************************************************
Decode and return the user bits from the raw LTC decoded bits in the
ring buffer.

Returns True if there is a valid timecode in the ring buffer

In general this is only true immediately after the decode method returns
a non-zero timecode sample sync

See timecode page 33
**********************************************************************/
int 
LTCdecoder::getUserBits(LTCuserBits *bits)
{
    if(_validTimeCode) { // verify that valid timecode is in buffer
        int begin = (_bufferIndex - 78 + 80) % 80; // point to beggining of timecode

        bits->user1 = compute(begin,   4, 4, _ringBuffer);
        bits->user2 = compute(begin,  12, 4, _ringBuffer);
        bits->user3 = compute(begin,  20, 4, _ringBuffer);
        bits->user4 = compute(begin,  28, 4, _ringBuffer);
        bits->user5 = compute(begin,  36, 4, _ringBuffer);
        bits->user6 = compute(begin,  44, 4, _ringBuffer);
        bits->user7 = compute(begin,  52, 4, _ringBuffer);
        bits->user8 = compute(begin,  60, 4, _ringBuffer);
    }
    return(_validTimeCode);
}


/**********************************************************************
Return the audio sample corresponding to the beggining and the end of
the timecode.  

We should return a double when we want to get sub-sample accuracy and
split hairs!
**********************************************************************/
int
LTCdecoder::getStartStopSample(LONGLONG *start, LONGLONG *stop)
{
    if(_validTimeCode) { // verify that valid timecode is in buffer
        *start = _syncSample;
        *stop  = _endSample;
    }

    return(_validTimeCode);
}


/**********************************************************************
Decode and return the TimeCode from the raw LTC decoded bits in the
ring buffer.

Returns True if there is a valid timecode in the ring buffer

In general this is only true immediately after the decode method returns
a non-zero timecode sample sync

See timecode page 33
**********************************************************************/
int
LTCdecoder::getTimeCode(TimeCode *tc)
{
    if(_validTimeCode) { // verify that valid timecode is in buffer
        int hour, minute, second, frame;
        int begin = (_bufferIndex - 78 + 80) % 80; // point to beggining of timecode

        frame  =    compute(begin,  0, 4, _ringBuffer); // frame units 0-3 1,2,4,8
        frame += 10*compute(begin,  8, 2, _ringBuffer); // frame tens  0-1 1,2

        second =    compute(begin, 16, 4, _ringBuffer);
        second+= 10*compute(begin, 24, 3, _ringBuffer);

        minute =    compute(begin, 32, 4, _ringBuffer);
        minute+= 10*compute(begin, 40, 3, _ringBuffer);

        hour   =    compute(begin, 48, 4, _ringBuffer);
        hour  += 10*compute(begin, 56, 2, _ringBuffer);

        tc->SetTime(hour, minute, second, frame);   // XXX for now
    }
    return(_validTimeCode);
}


/**********************************************************************
add a bit to the ringbuffer.

Will return true if the sync bits at the end of a timecode are encountered.

NOTE: we don't have to reset _onesCount after finding sync, the next 0 will!
**********************************************************************/
int LTCdecoder::_addBuffer(int bit, LONGLONG sample)
{
_bitsRecorded++;
_ringBuffer[_bufferIndex].value  = bit;
_ringBuffer[_bufferIndex++].sample = sample;
_bufferIndex%=80;
_onesCount = bit ? (_onesCount + 1) : 0;

return((_onesCount==12)&&(_bitsRecorded>77));
}


/**********************************************************************
Accept a new hunk of audio, decode the bits present in it, and return
the sample number corresponding to the timeCode synch (Rising edge of Bit
Zero) if a timeCode was completed being decoded.
**********************************************************************/
int
LTCdecoder::decodeBuffer(short **buf, int *bufferSize)
{
int index;
int timeCodeFound = 0;
short *buffer = *buf;
int newWaveState;
int bit;

for(index = 0; (index < *bufferSize) && (!timeCodeFound); index++) {
   _samplesProcessed++; // another day another sample

   newWaveState = _waveState?(buffer[index]+_verticalEpsilon)>0
                            :(buffer[index]-_verticalEpsilon)>0;

   if(newWaveState==_waveState) {
      _sampleWidth++;
   }
   else { // new bit
       _waveState = newWaveState;

       if(4*_sampleWidth > 3 * _bitWidth) { // long?
           bit = 0;
           _bitWidth = _sampleWidth;
       }
       else {                               // short
           bit = (_lastBit==1)?2:1;           // only a valid one if following 0
           _bitWidth = 2*_sampleWidth;
       }
       _lastBit = bit;

#ifdef DEBUG
#if 0
       if(bit!=2)
           printf("%8d %d width= %d samples\n", 
               _bitsRecorded, bit, _sampleWidth);
#endif
#endif
       _sampleWidth = 0;

       if(bit!=2) { // valid bit
           if(this->_addBuffer(bit, _samplesProcessed-2)) { // add bit to the buffer
               // found sync!
               int begin = (_bufferIndex - 78 + 80) % 80; // beggining of timecode
               _syncSample = _ringBuffer[begin].sample; // return the sample at bit zero!

               // XXX this is not terribly accurate!  
               // Since we greedy decode tc before the final 2 bits are read
               // we add an approximate 2 bits of samples back in!
               // Since at 44.1KHz 2 bits is approximately 60 samples we
               // have definitely lost some accuracy.
               // (If people care about this value, we should wait until the
               //  entire TC is decoded and accurately determine this value!)
               _endSample = _samplesProcessed + 2 * _bitWidth;

               timeCodeFound = 1;
               _validTimeCode = 1;
           } /* sync found */
       } /* valid bit */
       else {
           _validTimeCode = 0;
       }
   } /* new bit */
}

*bufferSize-= index; 
(*buf)+= index;

return(timeCodeFound);
}