root/experimental/components/Packetizer/trunk/Packetizer-metadata/src/Depacketizer.cpp @ 5182

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

Copyright 2006 Virginia Polytechnic Institute and State University

This file is part of the OSSIE Depacketizer.

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

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


#include <string>
#include <iostream>
#include <fstream>
#include "Depacketizer.h"

#undef LOGGING

#ifdef LOGGING
#define LOG_SIZE_MAX 5000
#endif

#define BIT0 0
#define BIT1 1

Depacketizer_i::Depacketizer_i(const char *uuid, omni_condition *condition) : Resource_impl(uuid), component_running(condition) 
{
    dataIn = new standardInterfaces_i::realChar_p("bitsIn");
    dataOut = new standardInterfaces_i::realChar_u("bitsOut");

    pnSyncCodeThreshold = PN_SYNC_CODE_LENGTH - 13;
    operationalMode = EXTRACT_PN_SYNC_CODE;
    
    //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();

}

Depacketizer_i::~Depacketizer_i(void)
{   
    delete dataIn;
    delete dataOut;
}

void Depacketizer_i::run( void * data )
{
    ((Depacketizer_i*) data)->run_loop();
}

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

    p = dataIn->getPort(portName);

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

    p = dataOut->getPort(portName);

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

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

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

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

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

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

void Depacketizer_i::configure(const CF::Properties& props) throw (CORBA::SystemException, CF::PropertySet::InvalidConfiguration, CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, Depacketizer, "configure() invoked")
    
    DEBUG(3, Depacketizer, "props length : " << props.length())
}


void Depacketizer_i::run_loop()
{
    DEBUG(3, Depacketizer, "run_loop() thread started")

#if 0

#ifdef LOGGING
    std::ofstream output_bits_log;
    output_bits_log.open("output_bits_log.dat");
    unsigned long log_size_counter(0);
#endif

    PortTypes::CharSequence data_block_out;
    data_block_out.length( DATA_BLOCK_LENGTH );
    
    PortTypes::CharSequence *bits_in(NULL);
    
    unsigned int N;  // CORBA input block length
    unsigned int i;  // counter

    while( true ) {

        // Read input from provides port
        dataIn->getData(bits_in, metadata);
        N = bits_in->length();
        DEBUG(7, Depacketizer, "got " << N << " samples")
            
#ifdef LOGGING
        for (i=0; i<N; i++) {
            if (log_size_counter < LOG_SIZE_MAX )
                output_bits_log << (int) (*bits_in)[i] << " ";
            log_size_counter++;
        }
#endif

        for (i=0; i<N; i++) {

            switch ( operationalMode ) {
            case EXTRACT_PN_SYNC_CODE:
                //
                inputBuffer.Push( (*bits_in)[i] );
                rxy = CorrelateSequence( pnSyncCode, PN_SYNC_CODE_LENGTH );
                if ( abs(rxy) > pnSyncCodeThreshold ) {
                    invertBits = ( rxy < 0 ) ? true : false;
                    DEBUG(5, Depacketizer, "SYNC CODE FOUND, inversion: " << invertBits)
                    DEBUG(5, Depacketizer, "  sync rxy = " << rxy)
                    operationalMode = EXTRACT_CONTROL_CODES;
                    inputBuffer.Release();
                }
                break;
            case EXTRACT_CONTROL_CODES:
                //
                inputBuffer.Push( (*bits_in)[i] );
                numBitsExtracted++;

                if ( numBitsExtracted == PN_CONTROL_CODE_LENGTH ) {
                    DEBUG(5, Depacketizer, "Extracting control code " << numControlCodesExtracted)
                    rxy = CorrelateSequence( pnCtrlCode, PN_CONTROL_CODE_LENGTH );
                    controlSequence[numControlCodesExtracted] = invertBits ? -rxy : rxy;
                    DEBUG(5, Depacketizer, "  rxy = " << controlSequence[numControlCodesExtracted])
                    numControlCodesExtracted++;
                    numBitsExtracted = 0;
                    inputBuffer.Release();

                    if ( numControlCodesExtracted == NUM_CONTROL_CODES ) {
                        DEBUG(5, Depacketizer, "CONTROL CODES EXTRACTED");
                        DecodeControlSequence();
                        DEBUG(5, Depacketizer, "Packet ID: " << controlOutput)

                        // Set mode to extract data block
                        numBitsExtracted = 0;
                        inputBuffer.Release();
                        operationalMode = EXTRACT_DATA_BLOCK;
                    }
                }
                break;
            case EXTRACT_DATA_BLOCK:
                //
                data_block_out[numBitsExtracted++] = invertBits ? 1-(*bits_in)[i] : (*bits_in)[i];

                if ( numBitsExtracted == DATA_BLOCK_LENGTH ) {
                    DEBUG(1, Depacketizer, "DATA BLOCK EXTRACTED!");
                    
                    DEBUG(1, Depacketizer, "pushing " << data_block_out.length() << " data samples")
                    metadata->packet_id = (unsigned int) controlOutput;
                    dataOut->pushPacket( data_block_out, *metadata );

                    // Reset counter variables
                    numControlCodesExtracted = 0;
                    numBitsExtracted = 0;
                    operationalMode = EXTRACT_PN_SYNC_CODE;
                    for (unsigned int j=0; j<PN_SYNC_CODE_LENGTH; j++)
                        inputBuffer.Push( 0 );
                }
                break;
            }
        }

        // Release input buffer
        dataIn->bufferEmptied();


    }
    DEBUG(3, Depacketizer, "run_loop() has ended")
#ifdef LOGGING
    output_bits_log.close();
#endif

#endif // 0
}