image_send.c

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

/***************************************************************************
 *    image_send.c  -  Sends an image
 ***************************************************************************/

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

/*************************************************************************
 *  Changelog
 *  04/03/05 - ineiti - adjusted description
 *************************************************************************/

/**
 * Sends a pre-computed image. The image must be included and available
 * as a Gimp-C-image. The program expects to find gimp_* to work with.
 *  When first connecting, it takes the size of the image to be 
 * sqrt(size_output), but after this, one can set config->size to a
 * different value.
 */

#include "spc.h"
#include "einstein_small.h"


#define DBG_LVL 0


typedef struct {
  // Change the size of the sent image
  int size; // 0
}
config_t;

typedef struct {
  // The picture itself
  image_t pic;
  // The size of the sent image
  int size;
}
stats_t;

// ADD HERE anything you want!
typedef struct {
}
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

  stats->pic.data = NULL;
  config->size = stats->size = 0;

  // 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
}


/*
 * To configure the inputs
 * this is called when the output-sizes change.
 */
int send_configure_inputs( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  config_t *config;
  stats_t *stats;
  int y, x, index_gimp, index_pic, gimp_x, gimp_y, bpp;
  int size_bytes;

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

  if ( config->size ){
    stats->size = config->size;
  } else {
    stats->size = sqrt( size_out(0) * 8 );
  }
  PR_DBG( 4, "Getting size_out of %i -> size is %i\n", 
	  size_out(0), stats->size );

  // Put the gimp-image included above
  stats->pic.width = stats->size;
  stats->pic.depth = stats->size;
  stats->pic.bpp = 1;
  size_bytes = ( stats->pic.width * stats->pic.depth * stats->pic.bpp + 7 ) / 8;
  if ( stats->pic.data ){
    swr_free( stats->pic.data );
  }
  PR_DBG( 4, "size_bytes is %i\n", size_bytes );
  stats->pic.data = swr_malloc( size_bytes );
  memset( stats->pic.data, 0, size_bytes );

  // Scale the gimp-picture to the actual picture
  bpp = gimp_image.bytes_per_pixel;
  for ( y=0; y<stats->size; y++ ){
    for ( x=0; x<stats->size; x++ ){
      gimp_y = y * gimp_image.height / stats->size;
      gimp_x = x * gimp_image.width / stats->size;
      index_gimp = ( gimp_y * gimp_image.width + gimp_x ) * bpp;
      if ( gimp_image.pixel_data[ index_gimp  ] ){
	index_pic = y * stats->size + x;
	stats->pic.data[ index_pic / 8 ] |= 1 << ( index_pic % 8 );
      }
    }
  }

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


/*
 * 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;
  stats_t *stats;

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


  // Definition - don't touch
  swr_sdb_free_config_struct( context->id, (void**)&config );
  swr_sdb_free_stats_struct( context->id, (void**)&stats );
  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
  stats_t *stats;
  int size;
  U8 *out;

  out = buffer_out(0);

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

  size = ( stats->pic.width * stats->pic.depth * stats->pic.bpp + 7 ) / 8;
  if ( size > size_out(0) ){
    PR_DBG( 4, "Can't send the whole picture, scaling\n" );
  }
  memcpy( out, stats->pic.data, min( size_out(0), size ) );

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

/*
 * This is the `destructor'.
 */
int send_finalize( swr_sdb_t *context ) {
  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( 0, 1, 1, 2 );
  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( "size" );
  UM_STATS_IMAGE( "picture" );
  UM_STATS_INT( "size" );

  /**
   * 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,DOUBLE}, 0 );
   * UM_OUTPUT( SIG_{U8,SYMBOL_{S16,COMPLEX,MMX},SAMPLE_S12,S32,DOUBLE}, 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_configure_inputs  = send_configure_inputs;
  desc->fn_finalize          = send_finalize;

  // And register the module in the SPM. Change the name!
  send_id = swr_cdb_register_spc( &desc, "image_send" );
  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" );
  }
}