Logo Search packages:      
Sourcecode: camserv version File versions  Download package

filter.c

/*  camserv - An internet streaming picture application
 *
 *  Copyright (C) 1999-2002  Jon Travis (jtravis@p00p.org)
 *
 *  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.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "ltdl.h"
#include "log.h"
#include "camconfig.h"
#include "filter.h"
#include "video.h"

#define MODNAME  "filter"

struct filter_st {
  char section_name[ MAX_SECTION_NAME + 1 ];
  Filter_Init_Func filter_init;
  Filter_Deinit_Func filter_deinit;
  Filter_Func_Func filter_func;
  ModInfo_QueryFunc modinfo_func;
  void *filter_cldat;
};

/*
 * filter_list_init:  Initialize the filter list.  This routine will
 *                    loop through all of the filters and notify them
 *                    all that they need to initialize (in addition to
 *                    storing returned clientdata information from the
 *                    filter module)
 *
 * Arguments:         filters = Filter list as returned by filter_setup
 *                    ccfg    = Camera configuration
 */

void filter_list_init( Filter *filters, CamConfig *ccfg ){
  int i;

  if( filters == NULL ) return;

  for( i=0; filters[ i ].filter_init != NULL; i++ ){
    void *fres;

    fres = filters[ i ].filter_init( ccfg, filters[ i ].section_name );
    filters[ i ].filter_cldat = fres;
  }
}

/*
 * filter_list_deinit:  Deinitialize all of the filters in the filter list.
 *
 * Arguments:           filters = Filter list as returned by filter_setup
 */

void filter_list_deinit( Filter *filters ){
  int i;

  for( i=0; filters[ i ].filter_init != NULL; i++ ){
    filters[ i ].filter_deinit( filters[ i ].filter_cldat );
  }
}

/*
 * filter_list_process:  Process picture information through all of the
 *                       filters.  The filters may change the composition
 *                       of the picture, the size of it, etc.  It is required
 *                       that the locations for storing the pictures be at 
 *                       least as big as the maximum picture size.
 *
 * Arguments:            filters = Filter list to pass the pictures through
 *                       picture = Input picture to filter
 *                       final_pic_out = Location to place final picture
 *                       vinfo = Information about 'picture'
 *                       out_vinfo = Information about 'final_pic_out'
 */

void filter_list_process( Filter *filters, char *picture, char *final_pic_out,
                    const Video_Info *vinfo, Video_Info *out_vinfo )
{
  Video_Info last_vinfo;
  char *last_out;
  int i;

  last_out = picture;
  last_vinfo = *vinfo;
  for( i=0; filters[ i ].filter_init != NULL; i++ ){
    char *outdata;
    Video_Info outvinfo;
    int is_last_filter;

    is_last_filter = (filters[ i + 1 ].filter_init == NULL ? 1 : 0);

    if( is_last_filter )
      outdata = final_pic_out;
    else
      outdata = NULL;

    filters[ i ].filter_func( last_out, &outdata, filters[ i ].filter_cldat,
                        &last_vinfo, &outvinfo );
    last_out = outdata;
    last_vinfo = outvinfo;
  }

  if( last_out != final_pic_out ){
    memmove( final_pic_out, last_out, last_vinfo.nbytes );
  }

  *out_vinfo = last_vinfo;
}

/*
 * filter_setup:  Attempt to use filter information from the cam config to
 *                load the filter libraries.
 *                
 * Arugments:     ccfg = Camera configuration
 *                reserr = Err result.  == 0 on no error, 1 if an error occured
 *          
 * Return values:  reserr should be checked for error results.  The return
 *                 value is filter information to be passed into other filter_
 *                 commands.
 */

Filter *filter_setup( CamConfig *ccfg, int *reserr ){
  int err, nfilters, i;
  const char *val;
  char key[ 1024 ];
  lt_dlhandle dlhandle;
  Filter *filters;

  nfilters = camconfig_query_int( ccfg, SEC_FILTERS, "num_filters", &err );
  if( err ) {
    *reserr = 0;
    return NULL;
  }

  if( (filters = malloc( sizeof( *filters ) * (nfilters+1) )) == NULL ){
    camserv_log( MODNAME, "Error allocating memory for filter storage!" );
    *reserr = 1;
    return NULL;
  }

  for( i=0; i< nfilters; i++ ){
    sprintf( key, "filter%d_section", i );
    if( (val = camconfig_query_str( ccfg, SEC_FILTERS, key )) == NULL ){
      camserv_log( MODNAME, "[%s]:%s key/val pair not "
               "found in cfg file", SEC_FILTERS, key );
      *reserr = 1;
      free( filters );
      return NULL;
    }

    strncpy( key, val, sizeof( key ) - 1 );
    key[ sizeof( key ) - 1 ] = '\0';
    if( (val = camconfig_query_str( ccfg, key, "path" )) == NULL ){
      camserv_log( MODNAME, "[%s]:path key/val pair not found in cfg file!",
               key );
      *reserr = 1;
      free( filters );
      return NULL;
    }

    camserv_log( MODNAME, "Loading filter [%s]", key );
    if( lt_dlinit() ) {
      camserv_log( MODNAME, lt_dlerror());
      *reserr = 1;
      free( filters );
      return NULL;
    }

    if( (dlhandle = lt_dlopen( val )) == NULL ){
      camserv_log( MODNAME, "filter%d: %s", i,  lt_dlerror());
      lt_dlexit();
      *reserr = 1;
      free( filters );
      return NULL;
    }

    strncpy( filters[ i ].section_name, key, 
           sizeof( filters[ i ].section_name ) - 1 );
    filters[ i ].section_name[ sizeof( filters[ i ].section_name ) - 1 ] ='\0';

    if( !(filters[ i ].filter_init = lt_dlsym( dlhandle, "filter_init" ))){
      camserv_log( MODNAME, "filter%d: %s", i, lt_dlerror() );
      lt_dlclose( dlhandle );
      lt_dlexit();
      *reserr = 1;
      free( filters );
      return NULL;
    }

    if( !(filters[ i ].filter_deinit = lt_dlsym( dlhandle, "filter_deinit" ))){
      camserv_log( MODNAME, "filter%d: %s", i, lt_dlerror() );
      lt_dlclose( dlhandle );
      lt_dlexit();
      *reserr = 1;
      free( filters );
      return NULL;
    }

    if( !(filters[ i ].filter_func = lt_dlsym( dlhandle, "filter_func" ))){
      camserv_log( MODNAME, "filter%d: %s", i, lt_dlerror() );
      lt_dlclose( dlhandle );
      lt_dlexit();
      *reserr = 1;
      free( filters );
      return NULL;
    }

    if( !(filters[ i ].modinfo_func = lt_dlsym( dlhandle, "modinfo_query" ))){
      camserv_log( MODNAME, "filter%d: %s", i, lt_dlerror() );
      lt_dlclose( dlhandle );
      lt_dlexit();
      *reserr = 1;
      free( filters );
      return NULL;
    }

    filters[ i ].filter_cldat = NULL;
  }

  filters[ nfilters ].filter_init = NULL;  /* Sentinal */

  *reserr = 0;
  return filters;
}

void filter_destroy( Filter *filter_list ){
  free( filter_list );
}

Generated by  Doxygen 1.6.0   Back to index