root/ossiedev/branches/jgaeddert/0.8.0/components/src/PacketEncoder.cpp @ 10677

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

Copyright 2010 by your_name_or_organization, all rights reserved.

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


#include <cstdio>
#include <string>
#include <iostream>

#include "config.h"
#include "PacketEncoder.h"

// include main.cpp (must define COMPONENT_OBJECT)
#define  COMPONENT_OBJECT PacketEncoder_i
#include "main.cpp"

PacketEncoder_i::PacketEncoder_i(const char *uuid, omni_condition *condition) :
    Resource_impl(uuid), component_running(condition)
{
    portUncodedDataIn = new standardInterfaces_i::realChar_p("UncodedDataIn");
    portCodedDataOut = new standardInterfaces_i::realChar_u("CodedDataOut");

    // create DSP packetizer object
    check     = LIQUID_CRC_16;
    fec_inner = LIQUID_FEC_NONE;
    fec_outer = LIQUID_FEC_HAMMING128;
    dec_msg_len = 0;
    enc_msg_len = packetizer_compute_enc_msg_len(dec_msg_len,check,fec_inner,fec_outer);
    p = packetizer_create(dec_msg_len,check,fec_inner,fec_outer);
}

PacketEncoder_i::~PacketEncoder_i(void)
{
    delete portUncodedDataIn;
    delete portCodedDataOut;

    // destroy DSP packetizer object
    packetizer_destroy(p);
}

// Static function for omni thread
void PacketEncoder_i::Run( void * data )
{
    ((PacketEncoder_i*)data)->ProcessData();
}

CORBA::Object_ptr PacketEncoder_i::getPort( const char* portName ) throw (
    CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, PacketEncoder, "getPort() invoked with " << portName)

    CORBA::Object_var p;

    p = portUncodedDataIn->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    p = portCodedDataOut->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

void PacketEncoder_i::start() throw (CORBA::SystemException,
    CF::Resource::StartError)
{
    DEBUG(3, PacketEncoder, "start() invoked")
    omni_mutex_lock  l(processing_mutex);
    if( false == thread_started )
    {
        thread_started = true;
        // Create the thread for the writer's processing function
        processing_thread = new omni_thread(Run, (void *) this);

        // Start the thread containing the writer's processing function
        processing_thread->start();
    }
}

void PacketEncoder_i::stop() throw (CORBA::SystemException, CF::Resource::StopError)
{
    DEBUG(3, PacketEncoder, "stop() invoked")
    omni_mutex_lock l(processing_mutex);
    thread_started = false;
}

void PacketEncoder_i::releaseObject() throw (CORBA::SystemException,
    CF::LifeCycle::ReleaseError)
{
    DEBUG(3, PacketEncoder, "releaseObject() invoked")

    component_running->signal();
}

void PacketEncoder_i::initialize() throw (CF::LifeCycle::InitializeError,
    CORBA::SystemException)
{
    DEBUG(3, PacketEncoder, "initialize() invoked")
}

void PacketEncoder_i::query( CF::Properties & configProperties ) throw (CORBA::SystemException, CF::UnknownProperties)
{
    if( configProperties.length() == 0 )
    {
        configProperties.length( propertySet.length() );
        for( unsigned int i = 0; i < propertySet.length(); i++ )
        {
            configProperties[i].id = CORBA::string_dup( propertySet[i].id );
            configProperties[i].value = propertySet[i].value;
        }
        return;
    } else {
        for( unsigned int i = 0; i < configProperties.length(); i++ ) {
            for( unsigned int j = 0; j < propertySet.length(); j++ ) {
                if( strcmp(configProperties[i].id, propertySet[i].id) == 0 ) {
                    configProperties[i].value = propertySet[i].value;
                }
            }
        }
    } // end if-else
}

void PacketEncoder_i::configure(const CF::Properties& props)
throw (CORBA::SystemException,
    CF::PropertySet::InvalidConfiguration,
    CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, PacketEncoder, "configure() invoked")

    static int init = 0;
    if( init == 0 ) {
        if( props.length() == 0 ) {
            std::cout << "configure called with invalid props.length - " << props.length() << std::endl;
            return;
        }
        propertySet.length(props.length());
        for( unsigned int j=0; j < props.length(); j++ ) {
            propertySet[j].id = CORBA::string_dup(props[j].id);
            propertySet[j].value = props[j].value;
        }
        init = 1;
    }

    std::cout << "props length : " << props.length() << std::endl;

    for ( unsigned int i = 0; i <props.length(); i++) {
        std::cout << "Property id : " << props[i].id << std::endl;

        if (strcmp(props[i].id, "DCE:094770a0-1017-11df-baab-001aa089d644") == 0) {
            // fec0 (inner coding scheme)

            const char * prop_str;
            props[i].value >>= prop_str;

            // convert string to FEC scheme
            fec_inner = liquid_getopt_str2fec(prop_str);
            if (fec_inner == LIQUID_FEC_UNKNOWN) {
                std::cerr << "error: PacketEncoder::configure(), invalid FEC scheme: '" << prop_str << "'" << std::endl;
                throw (0);
            }
        } else if (strcmp(props[i].id, "DCE:126dca6c-1017-11df-baab-001aa089d644") == 0) {
            // fec1 (outer coding scheme)

            const char * prop_str;
            props[i].value >>= prop_str;

            // convert string to FEC scheme
            fec_outer = liquid_getopt_str2fec(prop_str);
            if (fec_outer == LIQUID_FEC_UNKNOWN) {
                std::cerr << "error: PacketEncoder::configure(), invalid FEC scheme: '" << prop_str << "'" << std::endl;
                throw (0);
            }
        } else if (strcmp(props[i].id, "DCE:c294c02c-1de1-4f98-89ec-836158c4dd25") == 0) {
            // check (data validity check: crc/checksum)

            const char * prop_str;
            props[i].value >>= prop_str;

            // convert string to CRC scheme
            check = liquid_getopt_str2crc(prop_str);
            if (check == LIQUID_CRC_UNKNOWN) {
                std::cerr << "error: PacketEncoder::configure(), invalid CRC scheme: '" << prop_str << "'" << std::endl;
                throw (0);
            }
        } else {
            std::cerr << "error: PacketEncoder::configure(), unknown property" << std::endl;
            throw (0);
        }
    }

    // regenerate packetizer object
    p = packetizer_recreate(p,dec_msg_len,check,fec_inner,fec_outer);
}

void PacketEncoder_i::ProcessData()
{
    DEBUG(3, PacketEncoder, "ProcessData() invoked")

    PortTypes::CharSequence encodedDataOut;


    PortTypes::CharSequence *decodedDataIn(NULL);
    CORBA::UShort decodedDataIn_length;

    while(continue_processing())
    {
        portUncodedDataIn->getData(decodedDataIn);

        decodedDataIn_length = decodedDataIn->length();

        // check input length and re-create packetizer (if necessary)
        if (dec_msg_len != decodedDataIn_length) {
            // re-compute message lengths
            dec_msg_len = decodedDataIn_length;
            enc_msg_len = packetizer_compute_enc_msg_len(dec_msg_len,
                                                         check,
                                                         fec_inner,
                                                         fec_outer);

            // re-create packetizer object
            p = packetizer_recreate(p,
                                    dec_msg_len,
                                    check,
                                    fec_inner,
                                    fec_outer);
        }

        // create buffers (not efficient)
        // TODO : allocate buffers internally, realloc only when necessary
        unsigned char dec_msg[dec_msg_len];
        unsigned char enc_msg[enc_msg_len];

        // copy input to buffer
        for (unsigned int i=0; i<dec_msg_len; i++)
            dec_msg[i] = (*decodedDataIn)[i];
        portUncodedDataIn->bufferEmptied();

        // encode the packet
        packetizer_encode(p, dec_msg, enc_msg);

        // copy result to output buffer
        encodedDataOut.length(enc_msg_len);
        for (unsigned int i=0; i<enc_msg_len; i++)
            encodedDataOut[i] = enc_msg[i];

        // push data to output
        portCodedDataOut->pushPacket(encodedDataOut);
    }
}

bool PacketEncoder_i::continue_processing()
{
    omni_mutex_lock l(processing_mutex);
    return thread_started;
}