Subversion Repositories spdif_transmitter

#include "spdif_decoder.h"

#define PREAMBLE_Z         0x17

#define PREAMBLE_Y         0x27

#define PREAMBLE_X         0x47

#define SPDIF_PREAMBLE_L   0

#define SPDIF_PREAMBLE_H   3

#define SPDIF_PREAMBLE_W   4

#define SPDIF_SAMPLE_L     4

#define SPDIF_SAMPLE_H     27

#define SPDIF_SAMPLE_W     24

#define SPDIF_NVALID_L     28

#define SPDIF_NVALID_H     28

#define SPDIF_NVALID_W     1

#define SPDIF_PARITY_L     31

#define SPDIF_PARITY_H     31

#define SPDIF_PARITY_W     1

#define SPDIF_FIELD(v,n)   v.range(SPDIF_##n##_H, SPDIF_##n##_L)

//-----------------------------------------------------------------

// input: Handle rx data

//-----------------------------------------------------------------

void spdif_decoder::input(void)

{

    sc_uint <64> bmc_data = 0;

    sc_uint <32> data     = 0;

    do

    {

        wait();

    }

    while (rst_i.read());

    bool last_rx  = false;

    int  subframe = 0;

    bool rx       = false;

    while (true)

    {

        rx = rx_i.read();

        // Detect transition in preamble

        if (rx == false && last_rx == true)

        {

            // Wait for half a bit time to sample mid bit

            wait(m_divisor/2);

            // Preamble leading bits were 0111

            bmc_data = 0x7;

            // Capture remaining timeslots

            for (int i=4;i<64;i++)

            {

                wait(m_divisor);

                rx = rx_i.read();

                bmc_data[i] = rx;

            }

            // Check preamble type is expected

            if (subframe == 0)

                sc_assert(bmc_data.range(7,0) == PREAMBLE_Z);

            else if (subframe & 1)

                sc_assert(bmc_data.range(7,0) == PREAMBLE_Y);

            else

                sc_assert(bmc_data.range(7,0) == PREAMBLE_X);

            if (++subframe == 384)

                subframe = 0;

            // Decode BMC data

            for (int i=0;i<64;i+=2)

            {

                if (bmc_data[i+0] != bmc_data[i+1])

                    data[i/2] = 1;

                else

                    data[i/2] = 0;

            }

            // Check parity

            int ones_count = 0;

            for (int i=SPDIF_PREAMBLE_H+1;i<SPDIF_PARITY_L;i++)

                if (data[i])

                    ones_count += 1;

            if (ones_count & 1)

                sc_assert(SPDIF_FIELD(data, PARITY));

            else

                sc_assert(!SPDIF_FIELD(data, PARITY));

            sc_uint <SPDIF_SAMPLE_W> sample = SPDIF_FIELD(data, SAMPLE);

            // Valid sample

            if (!SPDIF_FIELD(data, NVALID))

            {

                sc_assert(m_rx_fifo.num_free() > 0);

                if (m_bits == 16)

                    m_rx_fifo.write(sample >> (SPDIF_SAMPLE_W - 16));

                else if (m_bits == 20)

                    m_rx_fifo.write(sample >> (SPDIF_SAMPLE_W - 20));

                else if (m_bits == 24)

                    m_rx_fifo.write(sample >> (SPDIF_SAMPLE_W - 24));

                else

                    sc_assert(!"Unsupported bit width");

            }

        }

        else

            wait();

        last_rx = rx;

    }

}