root/experimental/components/Packetizer/trunk/Packetizer-metadata/src/PacketizerDSP.h @ 5397

/****************************************************************************

Copyright 2007 Virginia Polytechnic Institute and State University

This file is part of the OSSIE Packetizer.

OSSIE Packetizer is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

OSSIE Packetizer is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with OSSIE Packetizer; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

****************************************************************************/


#ifndef PACKETIZERDSP_IMPL_H
#define PACKETIZERDSP_IMPL_H

#include <stdlib.h>
#include "PNCodes.h"
#include "sigproc/SigProc.h"

#define PN_SYNC_CODE_LENGTH     63
#define PN_CONTROL_CODE_LENGTH  7
#define NUM_CONTROL_CODES       4
#define MAX_PACKET_SIZE         4096

#define DEBUG_LEVEL 0

#define DEBUG_PRINTF(level, msg)            \
    if (DEBUG_LEVEL > level)                \
        printf(msg);

#define PACKETIZER_DEFINE_EXTRACT_API(X)    \
bool X(                                     \
    char* input,                            \
    unsigned int input_length,              \
    char* output,                           \
    unsigned int output_length,             \
    unsigned int &num_written);


extern "C" {
#include "binary_sequence.h"
}

/// Forward error correction scheme
enum FECScheme {
    REPEAT_1,       ///< Repeat code, rate 1/3
    RS_1,           ///< Reed solomon, rate... 
    CONV_1          ///< Convolutional, rate..., K=...
};

/// Interleaving scheme
enum InterleavingScheme {
    INT_1,          ///< Interleaving depth...
    INT_2           ///< Interleaving depth...
};

/// Cyclic redundancy check scheme
enum CRCScheme {
    CRC_1,
    CRC_2
};

/// Packet type
enum PacketType {
    ///\brief raw data packet with 400 bits input
    // pn_sync  63
    // control  4x7
    // p_id     7x3
    // data     400
    // -------------
    // total:   512
    PACKET_RAW_400=0,

    ///\brief Simplified packet with low overhead
    PACKET_LOW_OVERHEAD,

    ///\brief Fully-descriptive packet
    PACKET_RELIABLE_DATA
};

/** \brief Basic packet functionality
    
 */
class PacketizerDSP
{
  public:
    /// Default constructor
    PacketizerDSP();

    /// Destructor
    ~PacketizerDSP();

    ///\todo implement this method; for now assume packet can be configured by
    /// setting properties directly because SCA component wrapper inherits
    /// from the PacketizerDSP class
    void ConfigurePacket(
        PacketType _type,
        FECScheme _fec_inner,
        FECScheme _fec_outer,
        InterleavingScheme _int,
        CRCScheme _crc);

    /// Returns the necessary buffer size for processing given the current
    /// packet configuration
    unsigned int RequiredBufferSize(unsigned int input_length);

    /// \brief Completely constructs and encodes a packet from raw data bits
    ///
    /// \param[in]      input           raw un-encoded data bits
    /// \param[in]      input_length    length of input
    /// \param[in]      output          output buffer
    /// \param[in,out]  output_length   number of (maximum) output bits written
    /// \param[in]      type            type of packet to use
    void CreatePacket(
        PacketType type,
        char* input,
        unsigned int input_length,
        char* output,
        unsigned int output_length,
        unsigned int &num_written);

    /// \brief Completely finds and decodes a packet from raw data
    ///
    /// \param[in]      input           raw input
    /// \param[in]      input_length    length of input
    /// \param[in]      output          output buffer
    /// \param[in]      output_length   number of output bits available in buffer
    /// \param[out]     num_written     number of samples written to output buffer
    PACKETIZER_DEFINE_EXTRACT_API(ExtractPacket)

    /// \brief Assembles a packet from pre-encoded data bits
    ///
    /// \param[in]      input           buffer of pre-encoded data bits
    /// \param[in]      input_length    length of input buffer
    /// \param[in]      output          output buffer
    /// \param[in]      output_length   number of output bits available in buffer
    /// \param[out]     num_written     number of samples written to output buffer
    void AssemblePacket(
        char* input,
        unsigned int input_length,
        char* output,
        unsigned int output_length,
        unsigned int &num_written);

    ///
    void EncodePacketData(
        char * input,
        unsigned int input_length,
        char * output,
        unsigned int output_length,
        unsigned int &num_written);

    /// Finds the packet header by correlating with the P/N sync code
    bool FindHeader(
        char * input,
        unsigned int input_length,
        unsigned int &num_bits_read);

    /// \brief Extracts header from raw input
    ///
    /// \param[in]      input           raw input
    /// \param[in]      input_length    length of input
    /// \param[in]      output          output buffer
    /// \param[in]      output_length   number of output bits available in buffer
    /// \param[out]     num_written     number of samples written to output buffer
    PACKETIZER_DEFINE_EXTRACT_API(ExtractHeader)

    /// Extracts the basic packet type from the header
    bool DecodeHeader(
        char * input,
        unsigned int input_length);

    /// \brief Extracts sub header from raw input
    ///
    /// \param[in]      input           raw input
    /// \param[in]      input_length    length of input
    /// \param[in]      output          output buffer
    /// \param[in]      output_length   number of output bits available in buffer
    /// \param[out]     num_written     number of samples written to output buffer
    PACKETIZER_DEFINE_EXTRACT_API(ExtractSubheader)

    ///
    bool DecodeSubheader(
        char * input,
        unsigned int input_length);

    /// Extracts the remainder of the packet's raw data
    PACKETIZER_DEFINE_EXTRACT_API(ExtractPacketData)

    ///
    bool DecodePacketData(
        char * input,
        unsigned int input_length,
        char * output,
        unsigned int output_length,
        unsigned int &num_written);

  protected:
    PacketType packet_type;     ///< packet type identifier

    bool dynamic_packet_size;
    unsigned int packet_header_length;
    unsigned int packet_subheader_length;
    unsigned int packet_data_length;

    // Physical layer definitions
    char * pnSyncCode;                  ///< packet synchronization code
    binary_sequence_t * pn_sync_code;   ///< packet synchronization code shift register

    char * pnControlCode;               ///< packet control code
    binary_sequence_t * pn_control_code;///< packet control code shift register

    char * pnEOMCode;                   ///< packet EOM code
    binary_sequence_t * pn_eom_code;    ///< packet EOM code shift register

    // Media Access Control layer definitions
    FECScheme fec_inner;
    FECScheme fec_outer;
    InterleavingScheme interleaving;
    CRCScheme crc;

    // Network layer definitions
    unsigned long src_id;       ///< source identifier
    unsigned long dst_id;       ///< destination identifier

    // Transport layer definitions
    unsigned long packet_id;    ///< packet identifier
    unsigned long port_id;      ///< port identifier

    // Application layer definitions
    // ...

    /// Array of control code pointers
    char ** controlBlock;

    /// Configures control codes and other data based on packet type
    void ConfigurePacketType( PacketType type );
    
    // ------ Packetizer definitions ------

    /// Sets pointers in controlBlock to appropriate control codes
    void ConfigureControl( unsigned char id );


    // ------ Depacketizer definitions ------

    ///
    PACKETIZER_DEFINE_EXTRACT_API(ExtractPacketDataDynamicLength)

    ///
    PACKETIZER_DEFINE_EXTRACT_API(ExtractPacketDataFixedLength)

    binary_sequence_t * pn_sync_buffer;     ///< 
    binary_sequence_t * pn_control_buffer;  ///< 
    binary_sequence_t * pn_eom_buffer;      ///< 
    int rxy;                                ///< cross-correlator output

    unsigned int input_index;
    unsigned int output_index;

    enum {
        FIND_HEADER=0,
        EXTRACT_HEADER,
        DECODE_HEADER,
        EXTRACT_SUBHEADER,
        DECODE_SUBHEADER,
        EXTRACT_PACKET_DATA,
        DECODE_PACKET_DATA
    } op_mode;

    // 
    unsigned int num_header_bits_read;
    unsigned int num_control_codes_extracted;
    unsigned int num_control_bits_read;
    unsigned int new_packet_type;

    //
    unsigned int num_subheader_bits_read;

    //
    unsigned int num_packet_bits_read;

    bool invert_bits;

    // buffer pointers for signal processing; memory allocated externally
    char *buf1;
    char *buf2;
    unsigned int buf_len;
    void SetBuffer(char *_b1, char *_b2, unsigned int _len);
    
  private:
    /// Disallow copy constructor
    PacketizerDSP(PacketizerDSP&);

};

#endif