/* | | Copyright disclaimer: |   This software was developed at the National Institute of Standards |   and Technology by employees of the Federal Government in the course |   of their official duties. Pursuant to title 17 Section 105 of the |   United States Code this software is not subject to copyright |   protection and is in the public domain. | |   We would appreciate acknowledgement if the software is used. |*//* | Project:	WCDMA simulation environment | Module:      Collects received symbols from rake and outputs |              data when desired amount of symbols is available. | Author:      Tommi Makelainen, Nokia/NIST | Date:        April 20, 1999 | | History: |              April 20, 1999 Tommi Makelainen |                      Initial version. | */#include <stdio.h>#include <stdlib.h>#include <math.h>#include "config_wcdma.h"#include "spreading.h"#include "blockcollect.h"#ifndef TRUE#define TRUE 1#define FALSE 0#endif /* TRUE *//* -------------------------------------------------------------------- */static symbol_buffer_count = 0;static enum instance_state symbuf_alloc_list[MAX_SYMBOL_BUFFERS];static int general_init_flag = 0;static symbol_buffer_t symbolbuffers[MAX_SYMBOL_BUFFERS];/* -------------------------------------------------------------------- *//* * Function:	wcdma_symbolbuffer_init * Desc.:	Inits symbol collect buffer. * * Returns:	=> 0 allocated instance number, -1 if no free buffers. * * Note:	 */int wcdma_symbolbuffer_init(        int block_size)		/* IN: block size to collect */{    int instance, i;    /*     * Check for free symbol buffers.     */    if (symbol_buffer_count < MAX_SYMBOL_BUFFERS) {        /*         * If first call, initialize static data.         */        if (general_init_flag == FALSE) {            for (i=0; i < MAX_SYMBOL_BUFFERS; i++) {                symbuf_alloc_list[i] = FREE_INSTANCE;            } /* for */            general_init_flag = TRUE;        } /* if general_init_flag */        /*         * Find first free instance number.         */        instance = -1;        for (i=0; i < MAX_SYMBOL_BUFFERS; i++) {            if (symbuf_alloc_list[i] == FREE_INSTANCE) {                instance = i;                break;            }        } /* for */        if (instance == -1) return(-1); /* no free instances */        /*         * Init new buffer.         */        symbolbuffers[instance].size = block_size;        symbolbuffers[instance].fill_index = 0;        symbolbuffers[instance].read_index = 0;        symbolbuffers[instance].buffer =                      (double *)calloc(2*block_size, sizeof(double) );        /*         * Update symbol buffer allocation list.         */        symbuf_alloc_list[instance] = INSTANCE_IN_USE;        symbol_buffer_count++;        return(instance);    } else {        return(-1);    } /* else symbol_buffer_count */}/* -------------------------------------------------------------------- *//* * Function:	wcdma_symbolbuffer_free * Desc.:	Frees one frame buffer. * * Note:	 */void wcdma_symbolbuffer_free(int instance){    symbolbuffers[instance].size = 0;    symbolbuffers[instance].fill_index = 0;    symbolbuffers[instance].read_index = 0;    free( symbolbuffers[instance].buffer );    symbuf_alloc_list[instance] = FREE_INSTANCE;    symbol_buffer_count--;    return;}/* -------------------------------------------------------------------- *//* * Function:	wcdma_symbolbuffer * Desc.:	Collects input symbols until symbols enough for *              one frame is available. Then outputs one frame. * * Note:	 */int wcdma_symbolbuffer(           int instance,	/* IN: instance number */	   double data[],	/* IN: input data symbol vector */           int data_len,	/* IN: length of input data vector */           int *output_ready,   /* OUT: 1=output available, 0=no output */           double out[])	/* OUT: output symbols for one block */{     int i;    int blocksize;    double *symbolbuf;    int symbols_in_buffer;    int fill_index;    int first_part;    /*     * Get settings for this buffer.     */    blocksize = symbolbuffers[instance].size;    fill_index = symbolbuffers[instance].fill_index;    symbolbuf = symbolbuffers[instance].buffer;    /*     * Copy data to buffer.     */    if ( (fill_index + data_len) < (2*blocksize) ) {       memcpy(symbolbuf+fill_index, data, data_len * sizeof(double) );    } else {       first_part = 2*blocksize - fill_index;       memcpy(symbolbuf+fill_index, data, first_part * sizeof(double) );       memcpy(symbolbuf, data+first_part,                         (data_len - first_part) * sizeof(double) );    }    symbolbuffers[instance].fill_index = (fill_index+data_len) % (2*blocksize);    /*     * If enough data, copy one blocksize of data to output vector.     */    if (symbolbuffers[instance].fill_index >                          symbolbuffers[instance].read_index) {        symbols_in_buffer = symbolbuffers[instance].fill_index -                            symbolbuffers[instance].read_index;    } else {        symbols_in_buffer = 2*blocksize -                            symbolbuffers[instance].read_index +                            symbolbuffers[instance].fill_index;    }    if (symbols_in_buffer >= blocksize) {        if (symbolbuffers[instance].fill_index >                          symbolbuffers[instance].read_index) {            memcpy(out, symbolbuf+symbolbuffers[instance].read_index,                   blocksize * sizeof(double) );        } else {            first_part = 2*blocksize - symbolbuffers[instance].read_index;            memcpy(out, symbolbuf+symbolbuffers[instance].read_index,                   first_part * sizeof(double) );            if (first_part < blocksize) {                memcpy(out+first_part, symbolbuf,                       (blocksize-first_part) * sizeof(double) );             }        }        symbolbuffers[instance].read_index =             (symbolbuffers[instance].read_index + blocksize) %             (2*blocksize);        *output_ready = 1;    }    return(0);} /* wcmda_symbolbuffer *//* -------------------------------------------------------------------- */