sratematch.c

这是一个c＋＋编写的WCDMA链路采用RAKE接收的方针源代码

/*
 |
 | 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:      Static rate matching algorithm.
 | Author:      Tommi Makelainen
 | Date:        January 27, 1999
 |
 | History:
 |              January 27, 1999 Tommi Makelainen
 |                      Initial version.
 |
 |              June 18, 1999 Tommi Makelainen
 |                      Instances added.
 |
 */

#include <stdlib.h> 
#include <stdio.h>
#include <math.h>
#include "misdefs.h"
#include "sratematch.h"

#define NO_UPPER_BLOCK_SIZE -1
#define MAX_BLOCK_SIZE 10000
                  

/* ------------ S T A T I C   D A T A   S T R U C T U R E S ----------- */

#if 0
/*
 * Allocation list of available rate matching entities and the current count.
 */
static enum instance_state rate_match_alloc_list[MAX_RATE_MATCHINGS];
static rate_match_instance_count = 0;

/*
 * Parameters specific for each rate matching unit.
 */
static int transport_block_sizes[MAX_RATE_MATCHINGS];
static double punct_ratios[MAX_RATE_MATCHINGS];

/*
 * Initialization flag for static data structures.
 */
static int general_init_flag = FALSE;
#endif /* 0 */


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_rate_match_init
 * Desc.:       Inits rate matching and returns the allocated
 *              instance number.
 *
 * Returns:     => 0 allocated instance number, -1 if no free.
 *
 * Note:
 */
int wcdma_rate_match_init(
        int pilot_length,               /* IN: length of pilot in frame
                                               (in chips) */
        double finger_inc_level,        /* IN: finger select threshold */
        int nFingers)                   /* IN: number of fingers to use */
{
    int i, instance;
#if 0

    /*
     * If first call, initialize static data.
     */
    if (general_init_flag == FALSE) {
        for (i=0; i < MAX_RAKES; i++) {
            rate_match_alloc_list[i] = FREE_INSTANCE;
            init_flags[i] = TRUE;
        } /* for */
        general_init_flag = TRUE;
    } /* if general_init_flag */

    /*
     * Find first free instance number.
     */
    instance = -1;
    for (i=0; i < MAX_RAKES; i++) {
        if (rate_match_alloc_list[i] == FREE_INSTANCE) {
            instance = i;
            break;
        }
    }
    if (instance == -1) return(-1); /* no free instances */

    /*
     * Store rake specific data.
     */
    init_flags[instance] = TRUE;
    path_select_level[instance] = finger_inc_level;
    finger_count[instance] = nFingers;
    pilot_len[instance] = pilot_length;

    /*
     * Update rake allocation list and count.
     */
    rate_match_alloc_list[instance] = INSTANCE_IN_USE;
    rate_match_instance_count++;
#endif /* 0 */

    return(instance);
}


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_rate_match_free
 * Desc.:       Free one rate matching reservation.
 *
 * Note:
 */
void wcdma_rate_match_free(int instance)
{
#if 0
    rate_match_alloc_list[instance] = FREE_INSTANCE;
    rate_match_instance_count--;
#endif /* 0 */

    return;
}


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_rate_match
 * Desc.:       Do rate matching for uplink channels.
 *
 * Note:
 *              Can be used either for static or dynamic rate matching.
 */
int wcdma_rate_match(
           int Inputs[],        /* IN: input data symbol vector */
           int nInputs,         /* IN: length of input data vector */
           double max_punct_ratio,  /* IN: Max. ratio to puncture/repetite */
           int target_block_size,   /* IN: block size to match */
           int outData[])       /* OUT: matched output */
{
    double block_ratio;
    int temp_int_vector[MAX_BLOCK_SIZE];
    int temp_output_vector[MAX_BLOCK_SIZE];
    int *temp_input;
    int current_input_size;
    int *out_ptr;
    int output_size;
    int i, j, k, l, x, y, z, puncture;

    /*
     * Check the size of input block related to the allowed
     * output block size.
     * Check whether we need to puncture or repeat bits.
     */
    block_ratio = (target_block_size - nInputs) / (float)nInputs;
    if (block_ratio > max_punct_ratio) {
        printf("wcdma_rate_match: puncture/repetition ratio %g too large.\n",
               block_ratio);
        return(-1);
    }
    puncture = (block_ratio > 0) ? FALSE : TRUE;

    /*
     * Now puncture, if needed.
     * Puncture every z'th bit, until input fits to TC block.
     */
    temp_input = Inputs;
    if (puncture == TRUE) {
        x = nInputs;
        y = nInputs - target_block_size;
        if (y <= 1) {
            memcpy(temp_output_vector, temp_input, nInputs*sizeof(int));
            output_size = nInputs;
        }
        while (y > 1) {
            z = (int)ceil((double)x/(double)y);
            k = x / z;
            l = 0;
            /*
             * Puncture every z'th bit.
             */
            for (i=0; i < x; i++) {
                if ((i % z) != (z-1)) {
                    temp_int_vector[l++] = temp_input[i];
                }
            }
            x -= k;
            y -= k;
            memcpy(temp_output_vector, temp_int_vector, sizeof(int)*l);
            output_size = l;
            temp_input = temp_output_vector;
        }
        if (y == 1) output_size -= 1;
        memcpy(outData, temp_output_vector, sizeof(int)*(output_size));
    } else {
        /*
         * Repetition.
         */
        x = nInputs;
        y = target_block_size - nInputs;
        current_input_size = nInputs;
        if (y <= 1) {
            memcpy(temp_output_vector, temp_input, nInputs*sizeof(int));
            output_size = nInputs;
        }
        while (y > 1) {
            z = (int)ceil((double)x/(double)y);
            k = x / z;
            l = 0;
            /*
             * Repeat every z'th bit.
             */
            for (i=0; i < current_input_size; i++) {
                if ((i % z) != (z-1)) {
                    temp_int_vector[l++] = temp_input[i];
                } else {
                    temp_int_vector[l++] = temp_input[i];
                    temp_int_vector[l++] = temp_input[i];
                }
            }
            x -= k;
            y -= k;
            memcpy(temp_output_vector, temp_int_vector, sizeof(int)*l);
            output_size = l;
            temp_input = temp_output_vector;
            current_input_size = l;
        } /* while */
        if (y == 1) {
            output_size += 1;
            outData[0] = temp_output_vector[0];
            out_ptr = &(outData[1]);
        } else {
            out_ptr = outData;
        }
        memcpy(out_ptr, temp_output_vector, sizeof(int)*output_size);

    } /* else for repetition */

    return(0);
} /* wcdma_rate_match */


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_rate_dematch
 * Desc.:       Do dynamic rate dematching for uplink channels.
 *
 * Note: