root/experimental/components/SymbolSyncPoly/SymbolSyncPoly.cpp @ 3647

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

Copyright 2007 Virginia Polytechnic Institute and State University

This file is part of the OSSIE SymbolSyncPoly.

OSSIE SymbolSyncPoly 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 SymbolSyncPoly 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 SymbolSyncPoly; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

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


#include <string>
#include <iostream>
#include "SymbolSyncPoly.h"

SymbolSyncPoly_i::SymbolSyncPoly_i(const char *uuid, omni_condition *condition) : 
    Resource_impl(uuid), component_running(condition)
{
    dataIn_0 = new standardInterfaces_i::complexShort_p("baseband_in");
    dataOut_0 = new standardInterfaces_i::complexShort_u("symbols_out");


    //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();

    isConfigured_pulseShape = true;
    isConfigured_k          = false;
    isConfigured_m          = false;
    isConfigured_beta       = false;
    isConfigured_Npfb       = false;

}

SymbolSyncPoly_i::~SymbolSyncPoly_i(void)
{   
    delete dataIn_0;
    delete dataOut_0;
}

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

CORBA::Object_ptr SymbolSyncPoly_i::getPort( const char* portName ) throw (
    CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, SymbolSyncPoly, "getPort() invoked with " << portName)
    
    CORBA::Object_var p;

    p = dataIn_0->getPort(portName);

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

    p = dataOut_0->getPort(portName);

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

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

void SymbolSyncPoly_i::start() throw (CORBA::SystemException, 
    CF::Resource::StartError)
{
    DEBUG(3, SymbolSyncPoly, "start() invoked")
}

void SymbolSyncPoly_i::stop() throw (CORBA::SystemException, CF::Resource::StopError) 
{  
    DEBUG(3, SymbolSyncPoly, "stop() invoked")
}

void SymbolSyncPoly_i::releaseObject() throw (CORBA::SystemException,
    CF::LifeCycle::ReleaseError)
{
    DEBUG(3, SymbolSyncPoly, "releaseObject() invoked")
    
    component_running->signal();
}

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

void SymbolSyncPoly_i::configure(const CF::Properties& props)
throw (CORBA::SystemException,
    CF::PropertySet::InvalidConfiguration,
    CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, SymbolSyncPoly, "configure() invoked")
    
    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:41366fe0-e44e-11db-93b3-00123f63025f") == 0) {
            // pulse shape
            //CORBA::String simple_temp;
            //props[i].value >>= simple_temp;
            //simple_0_value = simple_temp;
        } else if (strcmp(props[i].id, "DCE:6911ce74-e44e-11db-be33-00123f63025f") == 0) {
            // k : samples per symbol
            CORBA::UShort simple_temp;
            props[i].value >>= simple_temp;
            _k = simple_temp;
            isConfigured_k = true;
        } else if (strcmp(props[i].id, "DCE:99bf718e-e44e-11db-99e4-00123f63025f") == 0) {
            // m : symbol delay
            CORBA::UShort simple_temp;
            props[i].value >>= simple_temp;
            _m = simple_temp;
            isConfigured_m = true;
        } else if (strcmp(props[i].id, "DCE:afc47b82-e44e-11db-b1f3-00123f63025f") == 0) {
            // beta : excess bandwidth factor
            CORBA::Float simple_temp;
            props[i].value >>= simple_temp;
            _beta = simple_temp;
            isConfigured_beta = true;
        } else if (strcmp(props[i].id, "DCE:bea3b19a-e44e-11db-a3dd-00123f63025f") == 0) {
            // Npfb : number of filters in bank
            CORBA::UShort simple_temp;
            props[i].value >>= simple_temp;
            _Npfb = simple_temp;
            isConfigured_Npfb = true;
        } else {
            // unknown property
            std::cerr << "ERROR: SymbolSyncPoly::configure() unknown property \""
               << props[i].id << "\"" << std::endl;
            throw CF::PropertySet::InvalidConfiguration();
        }
    }

    /// \todo configure filter bank type
    ///
    /// Once all properties have been configured, create the filter bank
    if ( isConfigured_k     &&
         isConfigured_m     &&
         isConfigured_beta  &&
         isConfigured_Npfb )
    {
        DEBUG(5, SymbolSyncPoly, "configuring filter bank for " << 
              "rrcos" << ", k=" << _k << ", m=" << _m << ", beta=" << _beta << ", Npfb=" << Npfb)
        ConfigureFilterBank("rrcos", _k, _m, _beta, _Npfb);
    }
}

void SymbolSyncPoly_i::ProcessData()
{
    DEBUG(3, SymbolSyncPoly, "ProcessData() invoked")

    PortTypes::ShortSequence I_out_0, Q_out_0;

    PortTypes::ShortSequence *I_in_0(NULL), *Q_in_0(NULL);
    unsigned int I_in_0_length, Q_in_0_length, N_in(0), N_out(0);
    short * I_in(NULL);
    short * Q_in(NULL);
    short * I_out(NULL);
    short * Q_out(NULL);

    while( true )
    {
        // Get data from port
        dataIn_0->getData(I_in_0, Q_in_0);

        // Read input data length
        I_in_0_length = I_in_0->length();
        Q_in_0_length = Q_in_0->length();

        if ( I_in_0_length != Q_in_0_length ) {
            // Not sure how to handle multiple-length inputs
            std::cerr << "ERROR: SymbolSyncPoly_i::ProcessData()" << std::endl
                      << "  => Not sure how to handle multiple-length inputs" << std::endl;
            throw 0;
        } else {
            N_in = I_in_0_length;
        }

        // Configure output data length
        if ( I_out == NULL ) {
            // Memory was never allocated; do so now
            I_out = new short[2*N_in/k];
            Q_out = new short[2*N_in/k];
            N_out = 2*N_in/k;
        } else if ( N_out < (2*N_in/k) ) {
            // Too little memory was allocated; renew
            delete [] I_out;
            delete [] Q_out;
            I_out = new short[2*N_in/k];
            Q_out = new short[2*N_in/k];
            N_out = 2*N_in/k;
        } else {
            // Memory is ok; do nothing
        }

        // Main signal processing algorithm
        SynchronizeAndDecimate(
            I_in, Q_in, N_in,
            I_out, Q_out, N_out);

        I_out_0.length(N_out);
        Q_out_0.length(N_out);

        /// \todo Initialize I_out_0 and Q_out_0 from array instead
        /// of copying values in loop
        for (unsigned int ii=0; ii<N_out; ii++) {
            I_out_0[ii] = I_out[ii];
            Q_out_0[ii] = Q_out[ii];
        }

        dataIn_0->bufferEmptied();
        dataOut_0->pushPacket(I_out_0, Q_out_0);
    }

    // Free the memory
    if ( I_out == NULL ) {
        delete [] I_out;
        delete [] Q_out;
    }
}