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

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

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

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:
    /// Initializing constructor
    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);
    
    ///
    void AssemblePacket(
        char* input,
        unsigned int input_length,
        char* output,
        unsigned int &output_length,
        PacketType type);

    /// Extracts the P/N sync code from the header
    bool ExtractPacketHeader(
        char * input,
        unsigned int input_length,
        unsigned int &num_bits_read);

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

    /// Extracts properties from the subheader
    bool ExtractPacketSubheader(
        char * input,
        unsigned int input_length,
        unsigned int &num_bits_read);

    /// Extracts the remainder of the packet, decoding as necessary
    bool ExtractPacketData(
        char * input,
        unsigned int input_length,
        char * output,
        unsigned int &output_length);

    void DecodePacket();

    /// Destructor
    ~PacketizerDSP();

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

    bool dynamic_packet_size;
    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 ------

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

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

    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;

    // 
    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;
    
  private:
    /// Disallow copy constructor
    PacketizerDSP(PacketizerDSP&);

};

#endif