root/ossiedev/branches/jeongo9/components/liquid-components/src/Resampler.cpp @ 10566

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

Copyright 2010 Virginia Polytechnic Institute and State University

This file is part of the OSSIE Resampler.

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

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


#include <string>
#include <iostream>
#include <stdio.h>

#include "config.h"
#include "Resampler.h"

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

Resampler_i::Resampler_i(const char *uuid, omni_condition *condition) :
    Resource_impl(uuid), component_running(condition)
{
    samplesInPort = new standardInterfaces_i::complexFloat_p("SamplesIn");
    samplesOutPort = new standardInterfaces_i::complexFloat_u("SamplesOut");

    verbose = 0;

    // create/initialize signal processing objects
    h_len = 13;
    r = 1.0f;
    bw = 0.5f;
    As = 60.0f;
    npfb = 32;
    resampler = resamp_crcf_create(r, h_len, bw, As, npfb);
}

Resampler_i::~Resampler_i(void)
{
    // delete ports
    delete samplesInPort;
    delete samplesOutPort;

    // delete resampling object
    resamp_crcf_destroy(resampler);
}

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

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

    CORBA::Object_var p;

    p = samplesInPort->getPort(portName);

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

    p = samplesOutPort->getPort(portName);

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

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

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

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

    component_running->signal();
}

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

void Resampler_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[j].id) == 0 ) {
                    configProperties[i].value = propertySet[j].value;
                }
            }
        }
    } // end if-else
}

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

#if 0
    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;
    }
#endif

    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:c5d3bd64-a554-11df-82df-001aa089d644") == 0) {
            // verbosity
            CORBA::Short simple_temp;
            props[i].value >>= simple_temp;
            verbose = simple_temp;
        } else if (strcmp(props[i].id, "DCE:d5d1f2c6-a554-11df-b9ee-001aa089d644") == 0) {
            // resampling rate
            CORBA::Float simple_temp;
            props[i].value >>= simple_temp;
            r = simple_temp;

            // validate input
            if (r < 0.5f || r > 2.0f) {
                fprintf(stderr, "error: Resampler::configure(), invalid resampling rate (%f) must be in [0.5,2]\n", r);
                throw CF::PropertySet::InvalidConfiguration();
            }

            // set resampler rate
            resamp_crcf_setrate(resampler, r);
        }
    }
}

void Resampler_i::ProcessData()
{
    DEBUG(3, Resampler, "ProcessData() invoked")

    PortTypes::FloatSequence I_out, Q_out;

    std::complex<float> x;      // input sample
    std::complex<float> y[12];  // temporary buffer for output samples
                                // TODO : ensure y is sufficiently sized


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

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

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

        unsigned int i;
        unsigned int n=0;
        unsigned int k;
        for (i=0; i<I_in_length; i++) {
            // strip input sample
            x.real( (*I_in)[i] );
            x.imag( (*Q_in)[i] );

            // push into resampler
            resamp_crcf_execute(resampler, x, y, &k);

            // extend output array, if necessary
            if (n + k > I_out.length()) {
                I_out.length(n + k);
                Q_out.length(n + k);
            }

            // append samples to output
            unsigned int j;
            for (j=0; j<k; j++) {
                I_out[n+j] = y[j].real();
                Q_out[n+j] = y[j].imag();
            }
            n += k;
        }

        // release input buffer
        samplesInPort->bufferEmptied();

        // push output packet
        samplesOutPort->pushPacket(I_out, Q_out);
    }
}

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