root/ossiedev/branches/jgaeddert/0.8.0/components/src/FrameSync64.cpp @ 10089

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

Copyright 2010 by your_name_or_organization, all rights reserved.

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


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

#include "config.h"
#include "FrameSync64.h"

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

static int callback(unsigned char * _header,  int _header_valid,
                    unsigned char * _payload, int _payload_valid,
                    framesyncstats_s stats,
                    void * _userdata);

FrameSync64_i::FrameSync64_i(const char *uuid, omni_condition *condition) :
    Resource_impl(uuid), component_running(condition)
{
    frameDataPortIn = new standardInterfaces_i::complexFloat_p("FrameSamplesIn");
    headerDataPortOut = new standardInterfaces_i::realChar_u("HeaderDataOut");
    payloadDataPortOut = new standardInterfaces_i::realChar_u("PayloadDataOut");

    // create liquid dsp object(s)
    verbose = true;
    framesyncprops_init_default(&fsprops);
    fs = framesync64_create(&fsprops,callback,(void*)this);
}

FrameSync64_i::~FrameSync64_i(void)
{
    delete frameDataPortIn;
    delete headerDataPortOut;
    delete payloadDataPortOut;

    // delete liquid dsp object(s)
    framesync64_destroy(fs);
}

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

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

    CORBA::Object_var p;

    p = frameDataPortIn->getPort(portName);

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

    p = headerDataPortOut->getPort(portName);

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

    p = payloadDataPortOut->getPort(portName);

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

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

void FrameSync64_i::start() throw (CORBA::SystemException,
    CF::Resource::StartError)
{
    DEBUG(3, FrameSync64, "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 FrameSync64_i::stop() throw (CORBA::SystemException, CF::Resource::StopError)
{
    DEBUG(3, FrameSync64, "stop() invoked")
    omni_mutex_lock l(processing_mutex);
    thread_started = false;
}

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

    component_running->signal();
}

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

void FrameSync64_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 FrameSync64_i::configure(const CF::Properties& props)
throw (CORBA::SystemException,
    CF::PropertySet::InvalidConfiguration,
    CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, FrameSync64, "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:0a3620cc-0aa1-11df-baab-001aa089d644") == 0) {
            // verbose
            CORBA::Boolean tmp;
            props[i].value >>= tmp;
            verbose = tmp;
        }
    }
}

void FrameSync64_i::ProcessData()
{
    DEBUG(3, FrameSync64, "ProcessData() invoked")

    PortTypes::FloatSequence *I_in(NULL), *Q_in(NULL);
    CORBA::UShort I_in_length, Q_in_length;

    unsigned int i;
    std::complex<float> x;

    while(continue_processing()) {
        frameDataPortIn->getData(I_in, Q_in);

        I_in_length = I_in->length();
        Q_in_length = Q_in->length();

        // operate one sample at a time
        for (i=0; i<I_in_length; i++) {
            // read separate I/Q streams and push into std::complex<float> type
            x.real() = (*I_in)[i];
            x.imag() = (*Q_in)[i];

            // execute synchronizer on sample (callback will be invoked once
            // frame has been received and decoded)
            framesync64_execute(fs,&x,1);
        }

        // free input buffer
        frameDataPortIn->bufferEmptied();
    }

    printf("************* destroying frame sync 64 object...\n");
    framesync64_destroy(fs);
}

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

static int callback(unsigned char * _header,  int _header_valid,
                    unsigned char * _payload, int _payload_valid,
                    framesyncstats_s _stats,
                    void * _userdata)
{
    // type-cast
    FrameSync64_i * fs_i = (FrameSync64_i*)_userdata;

    if (fs_i->verbose) {
        printf("callback invoked\n");

        printf("  header crc          : %s\n", _header_valid ?  "pass" : "FAIL");
        printf("  payload crc         : %s\n", _payload_valid ? "pass" : "FAIL");
    }

    if (_header_valid && _payload_valid) {
        fs_i->PushHeaderData(_header);
        fs_i->PushPayloadData(_payload);
    }

    return 0;
}

void FrameSync64_i::PushHeaderData(unsigned char * _header)
{
    // create output array and copy data
    PortTypes::CharSequence headerDataOut;
    headerDataOut.length(24);
    for (unsigned int i=0; i<24; i++)
        headerDataOut[i] = _header[i];

    // invoke pushPacket on the port
    headerDataPortOut->pushPacket(headerDataOut);
}

void FrameSync64_i::PushPayloadData(unsigned char * _payload)
{
    // create output array and copy data
    PortTypes::CharSequence payloadDataOut;
    payloadDataOut.length(64);
    for (unsigned int i=0; i<64; i++)
        payloadDataOut[i] = _payload[i];

    // invoke pushPacket on the port
    payloadDataPortOut->pushPacket(payloadDataOut);
}