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

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

/*
 * This module is to provide an example of how to create a new video
 * module for the camserv program. 
 */

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

#include "grafxmisc.h"
#include "camconfig.h"
#include "modinfo.h"
#include "video.h"
#include "grafxmisc.h"

/*
 * In the videodata structure, one should place all of the state information
 * they will need in subsequent callbacks.  This could include a number
 * of things:
 *
 *          o  File descriptors to open video devices.
 *          o  Allocated memory for image storage & manipulation
 *          o  Configuration information about the current state of the device.
 *
 *
 * Keep in mind that ultimately configuration information MUST be read from
 * the camconfig structure so that re-initialization can occur if required.
 * Therefore if something is read from the camcfg structure and then modified,
 * it should be re-written back to the camcfg struct.
 */

typedef struct video_data_st {
  char section_name[ MAX_SECTION_NAME + 1];
  unsigned char components[ 3 ]; /* Rval, gval, and bval                */
  int comp_mod;                  /* Current component being modified    */
  int direction;                 /* Direction of colour changing        */
  int width, height;
  int initialized;               /* 1 if device is initialized, else 0. */
} VideoData;

VideoData *video_open( CamConfig *ccfg, char *section_name );
void video_close( VideoData *vdata );
int video_init( VideoData *vdata, CamConfig *ccfg );
int video_deinit( VideoData *vdata );
int video_snap( VideoData *vdata, char *place_buffer, Video_Info *vinfo,
            CamConfig *ccfg );
int video_get_geom( VideoData *vid_dev, Video_Geometry *geom );

#define DEVICE_MAX_WIDTH  1024
#define DEVICE_MAX_HEIGHT 768
#define DEVICE_MIN_WIDTH  40
#define DEVICE_MIN_HEIGHT 30


/*
 * video_open:  This routine should perform any operations it will need to
 *              do to 'open' and allocate space for device storage.  This
 *              may be things such as opening the device file, allocating
 *              memory for state storage, and initializing states.
 *
 * Arguments:   ccfg = Camera configuration.
 *
 * Return values:  Returns NULL on failure, else a valid pointer to a new
 *                 state structure
 */

VideoData *video_open( CamConfig *ccfg, char *sec_name ){
  VideoData *vdata;

  if( (vdata = malloc( sizeof( *vdata ))) == NULL )
    return NULL;
  
  strncpy( vdata->section_name, sec_name, sizeof( vdata->section_name ));
  vdata->section_name[ sizeof( vdata->section_name ) - 1 ] = '\0';

  vdata->components[ 0 ] = 0;
  vdata->components[ 1 ] = 0;
  vdata->components[ 2 ] = 0;
  vdata->comp_mod = 0;         /* The red component */
  vdata->width = vdata->height = 0;
  vdata->initialized = 0;
  return vdata;
}

/*
 * video_close:  Close a video device, and deallocate all memory associated
 *               with the state information.  At this point, the video module
 *               should consider this to be the final access it has to any
 *               outside thang.
 *
 * Arguments:    vdata = VideoData as returned from the initial video_open.
 */

void video_close( VideoData *vdata ){
  free( vdata );
}

/*
 * video_init:  Initialize the video device.  This is slightly different from
 *              the open routine, in that it may be called often between
 *              an open and close call.  The purpose of this routine is
 *              to use configuration information to configure and 'init'
 *              the device.  This may be called periodically to reconfigure
 *              the video device.  For each init call, there should be 1
 *              de-init call, so the video device need not worry about
 *              init being called twice in a row.
 *
 * Arguments:   ccfg = Camera configuration to use in initialization
 * 
 * Return value:  Returns -1 on failure 0 on success.
 */

int video_init( VideoData *vdata, CamConfig *ccfg ){
  /* Use information from the camconfig structure to init the device */
  /* All of the VIDCONFIG_* settings should be checked and modified as 
   * necessary.  For instance when the device is initialized, if it is
   * black and white, it should be stored in the camconfig structure, as
   * should the actual used width,height, etc. */

  vdata->width  = camconfig_query_def_int( ccfg, SEC_VIDEO,
                                 VIDCONFIG_WIDTH, 320 );
  vdata->height = camconfig_query_def_int( ccfg, SEC_VIDEO,
                                 VIDCONFIG_HEIGHT, 240 );
  
  vdata->width = clip_to(vdata->width, DEVICE_MIN_WIDTH, DEVICE_MAX_WIDTH);
  vdata->height = clip_to( vdata->height, DEVICE_MIN_HEIGHT,DEVICE_MAX_HEIGHT);

  camconfig_set_int( ccfg, SEC_VIDEO,
                 VIDCONFIG_WIDTH,      vdata->width );
  camconfig_set_int( ccfg, SEC_VIDEO,
                 VIDCONFIG_HEIGHT,     vdata->height );
  camconfig_set_int( ccfg, SEC_VIDEO,
                 VIDCONFIG_MAXWIDTH,   DEVICE_MAX_WIDTH );
  camconfig_set_int( ccfg, SEC_VIDEO,
                 VIDCONFIG_MAXHEIGHT,  DEVICE_MAX_HEIGHT );
  camconfig_set_int( ccfg, SEC_VIDEO, 
                 VIDCONFIG_MINWIDTH,   DEVICE_MIN_WIDTH );
  camconfig_set_int( ccfg, SEC_VIDEO,
                 VIDCONFIG_MINHEIGHT,  DEVICE_MIN_HEIGHT );
  camconfig_set_int( ccfg, SEC_VIDEO,
                 VIDCONFIG_ISB_N_W,    0 );
  
  vdata->initialized = 1;
  return 0;
}

/*
 * video_deinit:  De-initialize the video device.  This is to perform
 *                temporary cleanup before a device is either re-initialized
 *                or closed.  This can be used to do things such as freeing
 *                captured video frames, or other cleanup procedures.
 *
 * Arguments:     vdata = Video data as returned from video_open
 * 
 * Return values: Returns -1 on failure, 0 on success.
 */

int video_deinit( VideoData *vdata ){
  return 0;
}


/*
 * video_snap:  Take a 'snapshot' from the video device.  This can range
 *              anywhere from reading device's, generating random noise,
 *              or anything one wants.  The picture taken can be in any
 *              format desired, however when it is placed into the place
 *              buffer it must either be in RGB (1 byte per component)
 *              format, or in the case of B&W a single byte containing the
 *              intensity of the pixel.  The place buffer is provided by
 *              the caller, and will contain enough space to store the
 *              maximum sized output from the snapshot.  In addition, the
 *              vinfo structure should contain information about the size
 *              of the taken picture, and various other attributes, such as
 *              B&W, height, width, etc.
 *
 * Arguments:   vdata        = Video data as returned by video_open.
 *              place_buffer = Location to place output data of the snapshot
 *              vinfo        = Location to place information about the snapshot
 *              ccfg         = Camera configuration to use if necessary.
 *
 * Return values:  Returns 0 on snapshot success, else -1
 */

int video_snap( VideoData *vdata, char *place_buffer, Video_Info *vinfo,
            CamConfig *ccfg )
{
  char *cp, *endcp;

  vinfo->width = vdata->width;
  vinfo->height = vdata->height;
  vinfo->is_black_white = 0;
  vinfo->nbytes = vinfo->width * vinfo->height * 3;

  endcp = place_buffer + vinfo->width * vinfo->height * 3;
  for( cp = place_buffer; cp < endcp; cp += 3 ){
    *(cp + 0) = vdata->components[ 0 ] ;
    *(cp + 1) = vdata->components[ 1 ] ;
    *(cp + 2) = vdata->components[ 2 ] ;
  }

  /* Very simple color changing */
  vdata->components[ vdata->comp_mod ] += vdata->direction *  5;
  if( vdata->components[ vdata->comp_mod ] == 0 ||
      vdata->components[ vdata->comp_mod ] == 255 )
  {  /* Change component */
    vdata->comp_mod = (vdata->comp_mod + 1) % 3;
    if( vdata->components[ vdata->comp_mod ] == 0 )
      vdata->direction = 1;
    else
      vdata->direction = -1;
  }

  return 0;
}

/*
 * video_get_geom:  Get geometry information about the video device. 
 *                  The video device must be opened before the geometry
 *                  can be gotten, so it will be passed in.  All of the
 *                  video device information which CAN be gotten, should.
 *
 * Arguments:       vid_device = Video device as returned from video_open
 *                  geom       = Location to place geometry information
 *
 * Return values:   Returns an ORed combination of VIDEO_GEOM_*, representing
 *                  which information in the returned structure is valid.
 *                  0 is returned on function failure.
 */

int video_get_geom( VideoData *vdata, Video_Geometry *geom ){
  geom->max_width  = DEVICE_MAX_WIDTH;
  geom->max_height = DEVICE_MAX_HEIGHT;
  geom->min_width  = DEVICE_MIN_WIDTH;
  geom->min_height = DEVICE_MIN_HEIGHT;

  if( vdata->initialized == 1 ){
      geom->cur_width  = vdata->width;
      geom->cur_height = vdata->height;
      return VIDEO_GEOM_MAX | VIDEO_GEOM_MIN | VIDEO_GEOM_CUR;
  }      

  return VIDEO_GEOM_MAX | VIDEO_GEOM_MIN;
}

/*
 * modinfo_query:  Routine to return information about the variables
 *                 accessed by this particular module.
 *
 * Return values:  Returns a malloced ModInfo structure, for which
 *                 the caller must free, or NULL on failure.
 */

ModInfo *modinfo_query(){
  ModInfo *res;
  char varname[ 1024 ];

  if( (res = modinfo_create( 2 )) == NULL )
    return NULL;

  sprintf( varname, "[%s]:%s", SEC_VIDEO, VIDCONFIG_WIDTH );
  modinfo_varname_set( res, 0, varname );
  modinfo_desc_set( res, 0, "Standard video width" );
  res->vars[ 0 ].type = MODINFO_TYPE_INT;
  
  sprintf( varname, "[%s]:%s", SEC_VIDEO, VIDCONFIG_HEIGHT );
  modinfo_varname_set( res, 1, varname );
  modinfo_desc_set( res, 1, "Standard video height" );
  res->vars[ 1 ].type = MODINFO_TYPE_INT;
  
  return res;
}

Generated by  Doxygen 1.6.0   Back to index