ldpc_encode.c

This a framework to test new ideas in transmission technology. Actual development is a LDPC-coder in

/***************************************************************************
 *    ldpc_encode.c  - LDPC encoding
 *                           -------------------
 *   begin                :  01/2003
 *   authors              :  Bernhard Bruhn
 *   emails               :  [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                Changes
 *                                -------
 * date - name - description
 *
 **************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/


/**
 *  Encodes a slot. Needs to have a modulator-module with a QPSK
 * modulation.
 */

#include "spc.h"
#include "graphcreate.h"
#include "encodehelpers.h"
#include <math.h>

#define DBG_LVL 0


typedef struct {
  // The index of the ldpc-code. For the moment, three codes
  // are implemented:
  // 1 - rate .25, size 4000
  // 2 - rate .5, size 3992
  // 3 - rate .75, size 3992
  int ldpc_code_id; // 1
}
config_t;

typedef struct {}
stats_t;

typedef struct {
  graphs *graph;
  int *iphi;
  int gap;
  int ldpc_code_id;
  int error;
}
private_t;



/*
 * The initialisation function, or constructor,
 * is called the first time this module is instantiated.
 */

int send_init( swr_sdb_t *context ) {
  // Begin system-definitions {
  config_t *config;
  stats_t *stats;
  MOD_INC_USE_COUNT;

  if ( sizeof( private_t ) > 0 )
    context->private_data = swr_malloc( sizeof( private_t ) );
  swr_sdb_get_config_struct( context->id, (void**)&config );
  swr_sdb_get_stats_struct( context->id, (void**)&stats );
  // } End of system-definitions

  private->ldpc_code_id	=-1;
  config->ldpc_code_id	=1;

  //allocate memory for graph
  private->graph=(graphs *)swr_malloc(sizeof(graphs));
  private->graph->vnodenum=0;
  private->graph->cnodenum=0;
  private->error = -1;

  // Begin system-definitions
  swr_sdb_free_stats_struct( context->id, (void**)&stats );
  swr_sdb_free_config_struct( context->id, (void**)&config );
  return 0;
  // End system-definitions
}


/*
 * Every time modules from the outside change the value of a configuration parameter,
 * this function is called.
 */

int send_reconfig( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  config_t *config;
  int vnodenum=0, cnodenum=0;
  swr_sdb_get_config_struct( context->id, (void**)&config );

  //  put new code into private->graph if config->ldpc_code_id has changed
  if(config->ldpc_code_id!=-1 && private->ldpc_code_id!=config->ldpc_code_id) {
    PR_DBG( 2, "loading ldpc code with ID %i\n", config->ldpc_code_id );
    if(!private->error)
      freeGraph(private->graph, private->iphi);
    private->ldpc_code_id=config->ldpc_code_id;
    private->error = getGraph(private->ldpc_code_id, private->graph,
                              &(private->gap), &(private->iphi) );
    if ( !private->error ) {
      vnodenum=(*private->graph).vnodenum;
      cnodenum=(*private->graph).cnodenum;
      size_in(0) = ( vnodenum - cnodenum ) / 8;
      PR_DBG( 2, "Put input-size to %i bytes\n", size_in(0) );
    }
  }

  // Definition - don't touch
  swr_sdb_free_config_struct( context->id, (void**)&config );
  return 0;
}


/*
 * This is the function that implements the `main method' of the class
 * Every class has got just ONE method/working-mode.
 */
int send_pdata( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  //  config_t *config; //added by bb 3.1.03
  stats_t *stats;
  U8 *in, *out;

  int node;
  int vnodenum=0, cnodenum=0, dnodenum=0;
  int row, col;
  int *tempa, *tempb;
  int *codeword;
  int i,j,index=0;

  in = buffer_in(0);
  if ( private->error ) {
    PR_DBG( 0, "Some error in the initialisation\n" );
    return -1;
  }
  out = buffer_out(0);

  swr_sdb_get_stats_struct( context->id, (void**)&stats );

  /*****************************
   * encode an information word *
   *****************************/

  vnodenum=(*private->graph).vnodenum;
  cnodenum=(*private->graph).cnodenum;
  dnodenum=vnodenum-cnodenum;

  PR_DBG(3, "vnodenum=%d, cnodenum=%d, size_in=%d bytes\n",
         vnodenum, cnodenum, size_in(0));
  codeword=(int*)swr_malloc(sizeof(int)*vnodenum);

  //copy bytes from 'in' to bits in 'codeword'
  if( size_in(0)*8 <= dnodenum ) {
    for( i=0; i<size_in(0)*8; i++ ) {
      if ( !(i%8) ) {
        index = in[ i/8 ];
      }
      codeword[i]=(index&1);
      index/=2;
    }
    for( i=size_in(0)*8; i<dnodenum; i++ ) {
      codeword[i]=0;
    }
  } else {
    PR_DBG( 1,"input > number of dnodes. Cutting the last %i bits.\n",
            size_in(0)*8-dnodenum);
    for( i=0; i<dnodenum; i++ ) {
      if ( !(i%8) ) {
        index = in[ i/8 ];
      }
      codeword[i]=(index&1);
      index/=2;
    }
  }

  // zero the remaining positions
  for(i=dnodenum; i<vnodenum; i++) {
    codeword[i]=0;
  }

  // allocate and clear temp
  tempa=(int *)swr_malloc(vnodenum*sizeof(int));
  tempb=(int *)swr_malloc(vnodenum*sizeof(int));
  cleararray(tempa, vnodenum);
  cleararray(tempb, vnodenum);

  // start by determining p1
  // A s^T
  graphmultiply(private->graph, 0, cnodenum-(private->gap),
                0, vnodenum-cnodenum,
                codeword, tempa);
  PR_DBG( 4,"A s^T\n");
  if (DBG_LVL>=4)
    printmatrix(tempa, 1, cnodenum-(private->gap));

  // T^-1 A s^T
  multiplybytminusone(private->graph, (private->gap), tempa, tempb);
  PR_DBG( 4,"T^-1 A s^T\n");
  if (DBG_LVL>=4)
    printmatrix(tempb, 1, cnodenum-(private->gap));

  // E (T^-1 A s^T)
  cleararray(tempa, (private->gap));
  graphmultiply(private->graph, cnodenum-(private->gap), cnodenum,
                vnodenum-cnodenum+(private->gap), vnodenum,
                tempb, tempa);
  PR_DBG( 4,"E (T^-1 A s^T) \n");
  if (DBG_LVL>=4)
    printmatrix(tempa, 1, (private->gap));

  // C s^T + E T^-1 A s^T
  graphmultiply(private->graph, cnodenum-(private->gap), cnodenum,
                0, vnodenum-cnodenum, codeword, tempa);
  PR_DBG( 4,"C s^T + E T^-1 A s^T \n");
  if (DBG_LVL>=4)
    printmatrix(tempa, 1, (private->gap));

  // phi^-1 (C s^T + E T^-1 A s^T)
  for (row=0; row<(private->gap); row++) {
    for (col=0; col<(private->gap); col++) {
      codeword[row+vnodenum-cnodenum]^=(*((private->iphi)+row*(private->gap)+col) & tempa[col]);
    }
  }
  PR_DBG( 4,"phi^-1 (C s^T + E T^-1 A s^T) \n");
  if (DBG_LVL>=4)
    printmatrix(codeword, 1, vnodenum);

  // now determine p2
  // A s^T + B p1^T
  cleararray(tempa, vnodenum);
  graphmultiply(private->graph, 0, cnodenum-(private->gap),
                0, vnodenum-(private->gap),
                codeword, tempa);
  PR_DBG( 4,"A s^T + B p1^T \n");
  if (DBG_LVL>=4)
    printmatrix(tempa, 1, cnodenum-(private->gap));

  // T^-1 (A s^T + B p1^T)
  multiplybytminusone(private->graph, private->gap, tempa, codeword+vnodenum-cnodenum+(private->gap));
  PR_DBG( 4,"T^-1 (A s^T + B p1^T) \n");
  if (DBG_LVL>=4)
    printmatrix(codeword, 1, vnodenum);

  // make sure that all constraints are fulfilled
  PR_DBG( 3,"making sure that all constraints are fulfilled \n");
  cleararray(tempa, vnodenum);
  graphmultiply(private->graph, 0, cnodenum,
                0, vnodenum,
                codeword, tempa);

  for (node=0; node<vnodenum; node++) {
    if(tempa[node]!=0) {
      PR_DBG( 0,"tempa[%i]!=0\n",node);
      return 0;
    }
  }

  // free allocated space
  PR_DBG( 3,"freeing tempa, tempb\n");
  swr_free (tempa);
  swr_free (tempb);


  //copy encoded data to output
  j=-1;
  for ( i=0; i<min(vnodenum,size_out(0)*8); i++ ) {
    if ( !( i % 8 ) ) {
      j++;
      out[j] = 0;
    }
    out[j] += codeword[i] << ( i % 8 );
  }
  if( size_out(0)*8 < vnodenum ) {
    PR_DBG( 0,"output to small: codeword does not fit in\n");
  } else {
    for ( i=vnodenum; i<size_out(0)*8; i++ ) {
      if ( !( i % 8 ) ) {
        j++;
        out[j] = 0;
      }
    }
  }

  swr_free (codeword);

  swr_sdb_free_stats_struct( context->id, (void**)&stats );
  return(0);
}

/**
 * User messages
 */
int send_custom_msg( swr_sdb_t *context, swr_usr_msg_t *data, swr_msgq ret ) {

  return 0;
}

/*
 * This is the `destructor'.
 */
int send_finalize( swr_sdb_t *context ) {
  swr_free( private->graph );
  if ( sizeof( private_t ) > 0 )
    swr_free( private );

  MOD_DEC_USE_COUNT;
  return 0;
}


/*
 * This function is called upon "insmod" and is used to register the
 * different parts of the module to the SPM.
 */
swr_spc_id_t send_id;
int send_module_init(void) {
  swr_spc_desc_t *desc;

  /**
   * Get a description-part from SPM
   * Give the following parameters:
   * Input-ports, output-ports, config-params, stat-params
   */
  desc = swr_spc_get_new_desc( 1, 1, 1, 0 );
  if ( !desc ) {
    PR_DBG( 0, "Can't initialise the module. This is BAD!\n" );
    return -1;
  }

  /**
   * Define the different parts of config and stats. You have to define
   * them in the same order as they appear in the structures. The names
   * can be freely chosen.
   *
   * UM_CONFIG_{INT,DOUBLE,STRING128,POINTER}( "name" );
   * UM_STATS_{INT,DOUBLE,STRING128,POINTER,BLOCK}( "name" );
   */
  UM_CONFIG_INT( "ldpc_code_id" );
  /**
   * The in- and outputs have also to be defined in the right order. First
   * port first. The additional flag is not used yet, but it will...
   *
   * UM_INPUT( SIG_{U8,SYMBOL_{S16,COMPLEX,MMX},SAMPLE_S12,S32}, 0 );
   * UM_OUTPUT( SIG_{U8,SYMBOL_{S16,COMPLEX,MMX},SAMPLE_S12,S32}, 0 );
   */
  UM_INPUT( SIG_U8, 0 );
  UM_OUTPUT( SIG_U8, 0 );

  // Initialise the callback-functions. Delete the ones you don't use
  desc->fn_init              = send_init;
  desc->fn_reconfigure       = send_reconfig;
  desc->fn_process_data      = send_pdata;
  desc->fn_custom_msg        = send_custom_msg;
  desc->fn_finalize          = send_finalize;

  // And register the module in the SPM. Change the name!
  send_id = swr_cdb_register_spc( &desc, "ldpc_encode_siso_ics" );
  if ( send_id == SWR_SPM_INVALID_ID ) {
    swr_spc_free_desc( desc );
    PR_DBG( 0, "Couldn't register the module!\n" );
    return 1;
  }
  PR_DBG( 4, "Ready\n" );
  return 0;
}


/*
 * This is called upon rmmod
 */
void send_module_exit( void ) {
  PR_DBG( 4, "Freeing id: %i\n", send_id );
  if ( swr_cdb_unregister_spc( send_id ) < 0 ) {
    PR_DBG( 0, "Still in use somewhere\n" );
  }
}