diff -r -N camserv-0.42/ChangeLog camserv-0.42_max/ChangeLog 0a1,7 > MAX 06-03-01 Added support for Gatos / ATI TV Capture Cards using > Gatos ( www.linuxvideo.org ) > > MAX 06-01-01 Added two new ./configure flags, one to turn off the > gdk library, one to force acceptance of libjpeg > MAX = Max Baker > diff -r -N camserv-0.42/README.GATOS camserv-0.42_max/README.GATOS 0a1,40 > camserv - A Streaming camera server. > Copyright (C) 1999-2000 Jon Travis > > Gatos/ATI Portions (C) 2001 Max Baker > > This is the very beginning of this patch, to add support for > ATI cards. > > > To make this work - > > Download Gatos-ATI from www.linuxvideo.org > > When compiling the gatos-ati/gatos subtree make sure you add the > configure flag --enable-shared to create the shared library version > of libgatos (libgatos.so.0.0.x) > > > Add patches, > make clean > > > NOTES: > This is still totally untested and assumed buggy / leaky / etc! > > This program now has to be run as suid root, in order for the ATI driver > to work. > > That makes this program VERY DANGEROUS, as this code has not been checked > for buffer overruns, or anything else associated with running open sockets > as root. Therefore if you use this, someone could EASILY hack into your box. > > Hopefully someone has a way around this, but I don't know enough about anything > to be of any good. > > The only way I am running this safely is to run it behind a firewall, and only allow > access from the outside machine where I run the relay program from. Otherwise > yer a sitting duck. > > -max diff -r -N camserv-0.42/camserv/Makefile.am camserv-0.42_max/camserv/Makefile.am 3,4c3,4 < INCLUDES =-I$(includedir) -I$(top_srcdir)/include -DDATDIR=\"${datadir}\" \ < -I${top_srcdir}/libltdl --- > INCLUDES = -I$(includedir) -I$(top_srcdir)/include -DDATDIR=\"${datadir}\" \ > -I${top_srcdir}/libltdl 30a31 > EXTRA_DIST += video_gatos.c 49a51,57 > if VIDEO_GATOS > libvideo_gatos_la_SOURCES = video_gatos.c camconfig.c > libvideo_gatos_la_LIBADD = -lgatos > gatos_ltlibs = libvideo_gatos.la > gatos_ldaddflags = "-dlopen " ${gatos_ltlibs} > endif > 57c65,66 < libvideo_basic.la --- > ${gatos_ltlibs} \ > libvideo_basic.la 71c80,81 < "-dlopen" libvideo_basic.la \ --- > ${gatos_ldaddflags} \ > "-dlopen " libvideo_basic.la \ diff -r -N camserv-0.42/camserv/picture_loop.c camserv-0.42_max/camserv/picture_loop.c 214a215,216 > if( signum == SIGUSR1 ) return; // max gatos > if( signum == SIGCHLD ) return; // max gatos diff -r -N camserv-0.42/camserv/video_gatos.c camserv-0.42_max/camserv/video_gatos.c 0a1,409 > /* camserv - An internet streaming picture application > * > * Copyright (C) 1999 Jon Travis (jon@dsndata.com) > * > * 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. > */ > > /* > * video_gatos.c (c)Max Baker 2001 > * This is a driver to use libgatos for ATI tuner cards > */ > > #include > #include > #include > > #include > #include > #include > #include > > #include "camconfig.h" > #include "modinfo.h" > #include "video.h" > > #define MODNAME "gatos" > > #define GATOSMOD_DEBUG ( VIDCONFIG_PREFIX "debug" ) > #define GATOSMOD_CAPTUREMODE ( VIDCONFIG_PREFIX "capturemode" ) > #define GATOSMOD_NUMBUF ( VIDCONFIG_PREFIX "doublebuffer" ) > #define GATOSMOD_OVERCLOCK ( VIDCONFIG_PREFIX "overclock" ) > #define GATOSMOD_CC ( VIDCONFIG_PREFIX "cc" ) > #define GATOSMOD_TVTYPE ( VIDCONFIG_PREFIX "tvtype" ) > #define GATOSMOD_CHANNEL ( VIDCONFIG_PREFIX "channel" ) > #define GATOSMOD_CHANNELBRIGHT ( VIDCONFIG_PREFIX "channel_brightness" ) > #define GATOSMOD_CHANNELCONTR ( VIDCONFIG_PREFIX "channel_contrast" ) > #define GATOSMOD_CHANNELHUE ( VIDCONFIG_PREFIX "channel_hue" ) > #define GATOSMOD_CHANNELSAT ( VIDCONFIG_PREFIX "channel_saturation" ) > #define GATOSMOD_BRIGHT ( VIDCONFIG_PREFIX "brightness" ) > #define GATOSMOD_CONTRAST ( VIDCONFIG_PREFIX "contrast" ) > #define GATOSMOD_SATURATION ( VIDCONFIG_PREFIX "saturation" ) > #define GATOSMOD_HUE ( VIDCONFIG_PREFIX "hue" ) > #define GATOSMOD_GAMMA ( VIDCONFIG_PREFIX "gamma" ) > #define GATOSMOD_COLD ( VIDCONFIG_PREFIX "cold" ) > #define GATOSMOD_FORMAT ( VIDCONFIG_PREFIX "format" ) > #define GATOSMOD_MUX ( VIDCONFIG_PREFIX "mux" ) > > #define GATOS_DEF_MUX 1 > #define GATOS_DEF_WIDTH 640 > #define GATOS_DEF_HEIGHT 480 > #define GATOS_DEF_CHANNEL 3 > /* > * 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_gatos_st { > char section_name[ MAX_SECTION_NAME + 1]; > int width, height; > int initialized; /* 1 if device is initialized, else 0. */ > int mux; > int channel; > int channelbright, channelcontr,channelhue,channelsat; > int bright, contrast, saturation, hue, gamma, cold; > int capturemode, format, numbuf, overclock; > int cc; > } VideoGatos; > > VideoGatos *video_open( CamConfig *ccfg, char *section_name ); > void video_close( VideoGatos *vdata ); > int video_init( VideoGatos *vdata, CamConfig *ccfg ); > int video_deinit( VideoGatos *vdata ); > int video_snap( VideoGatos *vdata, char *place_buffer, Video_Info *vinfo, > CamConfig *ccfg ); > int video_get_geom( VideoGatos *vid_dev, Video_Geometry *geom ); > > #define MAX(x,y) ( (x) > (y) ? (x) : (y) ) > #define MIN(x,y) ( (x) < (y) ? (x) : (y) ) > > > /* > * 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 > */ > > VideoGatos *video_open( CamConfig *ccfg, char *sec_name ){ > VideoGatos *vdata; > > int configerr,debug=0; > if( (vdata = malloc( sizeof( VideoGatos ))) == NULL ) > return NULL; > strncpy( vdata->section_name, sec_name, sizeof( vdata->section_name )); > vdata->section_name[ sizeof( vdata->section_name ) - 1 ] = '\0'; > > vdata->width = vdata->height = 0; > vdata->initialized = 0; > > gatos_init(GATOS_READ_BUFFER|GATOS_WRITE_BUFFER); > // debug - getting default values > if ( camconfig_query_int( ccfg, sec_name, GATOSMOD_DEBUG, &configerr ) == 1 ) debug=1; > if (debug) { > gatos_setverbosity(255); > fprintf(stderr, "capturemode : %d numbuff: %d overclock: %d cc: %d\n", > gatos_capturemode(), > gatos_numbuffer(), > gatos_overclock(), > gatos_CC() ); > fprintf(stderr, "tvtype: %d channelbright: %d channelcontr: %d channelhue: %d\n", > gatos_tvtype() , > gatos_chanbrightness(GATOS_DEF_CHANNEL) , > gatos_chancontrast(GATOS_DEF_CHANNEL) , > gatos_chanhue(GATOS_DEF_CHANNEL) ); > fprintf(stderr, "chansat: %d bright: %d contrast: %d saturation: %d hue: %d\n", > gatos_chansaturation(GATOS_DEF_CHANNEL) , > gatos_brightness() , > gatos_contrast(), > gatos_saturation(), > gatos_hue() ); > fprintf(stderr, "gamma: %d cold: %d format:%d \n", > gatos_gamma() , > gatos_cold(), > gatos_format() ); > } > vdata->initialized = 1; > 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 = VideoGatos as returned from the initial video_open. > */ > > void video_close( VideoGatos *vdata ){ > gatos_terminate(); > 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( VideoGatos *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. */ > int xcaptmax,ycaptmax,xcaptmin,ycaptmin; > int configerr; > char * secname = vdata->section_name; > > xcaptmax = gatos_xcaptmax(); > ycaptmax = gatos_ycaptmax(); > xcaptmin = gatos_xcaptmin(); > ycaptmin = gatos_ycaptmin(); > > vdata->width = camconfig_query_def_int( ccfg, SEC_VIDEO, > VIDCONFIG_WIDTH , GATOS_DEF_WIDTH ); > vdata->height = camconfig_query_def_int( ccfg, SEC_VIDEO, > VIDCONFIG_HEIGHT , GATOS_DEF_HEIGHT ); > > vdata->width = MAX( MIN( vdata->width, xcaptmax ), xcaptmin); > vdata->height = MAX( MIN( vdata->height,xcaptmax ),xcaptmin); > > gatos_setcapturesize(vdata->width, vdata->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, xcaptmax ); > camconfig_set_int( ccfg, SEC_VIDEO, > VIDCONFIG_MAXHEIGHT, ycaptmax ); > camconfig_set_int( ccfg, SEC_VIDEO, > VIDCONFIG_MINWIDTH, xcaptmin ); > camconfig_set_int( ccfg, SEC_VIDEO, > VIDCONFIG_MINHEIGHT, ycaptmin ); > camconfig_set_int( ccfg, SEC_VIDEO, > VIDCONFIG_ISB_N_W, 0 ); > > vdata->mux = camconfig_query_def_int( ccfg, secname, > GATOSMOD_MUX , GATOS_DEF_MUX ); > gatos_setmux(vdata->mux); // Composite Input (2 is tv) > > if (vdata->mux == 2) { // We're watching TV! > vdata->channel = camconfig_query_def_int( ccfg, secname, > GATOSMOD_CHANNEL , GATOS_DEF_CHANNEL ); > gatos_setchan(vdata->channel - 1); // 0 indexed.... > > vdata->channelbright = camconfig_query_int( ccfg, secname, GATOSMOD_CHANNELBRIGHT,&configerr); > if (vdata->channelbright != -1) gatos_setchanbrightness( vdata->channel,vdata->channelbright ); > vdata->channelcontr = camconfig_query_int( ccfg, secname, GATOSMOD_CHANNELCONTR,&configerr); > if (vdata->channelcontr != -1) gatos_setchancontrast( vdata->channel, vdata->channelcontr ); > vdata->channelhue = camconfig_query_int( ccfg, secname, GATOSMOD_CHANNELHUE,&configerr); > if (vdata->channelhue != -1) gatos_setchanhue( vdata->channel, vdata->channelhue ); > vdata->channelsat = camconfig_query_int( ccfg, secname, GATOSMOD_CHANNELSAT,&configerr); > if (vdata->channelsat != -1) gatos_setchansaturation( vdata->channel, vdata->channelsat ); > } > /* > vdata->XXX = camconfig_query_int ( ccfg, secname, GATOSMOD_, &configerr); > if (vdata->XXX != -1) gatos_set( vdata->XXX ); > */ > > vdata->bright = camconfig_query_int ( ccfg, secname, GATOSMOD_BRIGHT, &configerr); > if (vdata->bright != -1) gatos_setbrightness( vdata->bright ); > > vdata->contrast = camconfig_query_int ( ccfg, secname, GATOSMOD_CONTRAST, &configerr); > if (vdata->contrast != -1) gatos_setcontrast( vdata->contrast ); > > vdata->saturation = camconfig_query_int ( ccfg, secname, GATOSMOD_SATURATION, &configerr); > if (vdata->saturation != -1) gatos_setsaturation( vdata->saturation ); > > vdata->hue = camconfig_query_int ( ccfg, secname, GATOSMOD_HUE, &configerr); > if (vdata->hue != -1) gatos_sethue( vdata->hue ); > > vdata->gamma = camconfig_query_int ( ccfg, secname, GATOSMOD_GAMMA, &configerr); > if (vdata->gamma != -1) gatos_setgamma( vdata->gamma ); > > vdata->cold = camconfig_query_int ( ccfg, secname, GATOSMOD_COLD, &configerr); > if (vdata->cold != -1) gatos_setcold( vdata->cold ); > > vdata->numbuf = camconfig_query_def_int ( ccfg, secname, > GATOSMOD_NUMBUF, gatos_numbuffer() ); > > vdata->capturemode = camconfig_query_int ( ccfg, secname, GATOSMOD_CAPTUREMODE, &configerr); > if (vdata->capturemode != -1) gatos_setcapturemode( > vdata->capturemode, vdata->numbuf, 0 , 0 ); > > vdata->format = camconfig_query_int ( ccfg, secname, GATOSMOD_FORMAT, &configerr); > if (vdata->format != -1) gatos_setformat( vdata->format ); > > vdata->overclock = camconfig_query_int ( ccfg, secname, GATOSMOD_OVERCLOCK, &configerr); > if (vdata->overclock != -1) gatos_setoverclock( vdata->overclock ); > > vdata->cc = camconfig_query_int ( ccfg, secname, GATOSMOD_CC, &configerr); > if (vdata->cc != -1) gatos_setCC( vdata->cc ); > > 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( VideoGatos *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( VideoGatos *vdata, char *place_buffer, Video_Info *vinfo, > CamConfig *ccfg ) > { > > vinfo->width = vdata->width; > vinfo->height = vdata->height; > vinfo->is_black_white = 0; > vinfo->nbytes = vinfo->width * vinfo->height * 3; > > gatos_enable_capture(1); > if (gatos.usr1pid) kill(gatos.usr1pid,SIGSTOP) ; > usleep(50000); > if (gatos.usr1pid) kill(gatos.usr1pid,SIGSTOP) ; > gatos_enable_capture(0); > if (gatos.usr1pid) kill(gatos.usr1pid,SIGSTOP) ; > usleep(50000); > if (gatos.usr1pid) kill(gatos.usr1pid,SIGSTOP) ; > > gatos_rgbcapture(place_buffer); > 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( VideoGatos *vdata, Video_Geometry *geom ){ > geom->max_width = gatos_xcaptmax(); > geom->max_height = gatos_ycaptmax(); > geom->min_width = gatos_xcaptmin(); > geom->min_height = gatos_ycaptmin(); > > 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, "Capture image 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, "Capture image height" ); > res->vars[ 1 ].type = MODINFO_TYPE_INT; > > /* > modinfo_varname_set ( res, , GATOSMOD_ ); > modinfo_desc_set ( res, , "" ); > res->vars[ ].type = MODINFO_TYPE_INT; > */ > > return res; > } diff -r -N camserv-0.42/camserv.cfg camserv-0.42_max/camserv.cfg 0a1,45 > #* video_gatos - for ATI tuner cards > [video_gatos] > path /usr/local/lib/libvideo_gatos.so > debug 0 > #* mux == input source [1]Composite [2]TV Tuner [3]Svideo > mux 1 > #* channel is only affected when mux = 2 > #channel > #* brightness [0 - 200] > #brightness > #* contrast [0 - 200] > #contrast > #* saturation [0 - 200] > #saturation > #* hue [-90 - 90] > #hue > #* gamma [0 - 3] > #gamma > #* cold [0 or 1] > #cold > > > #* these are obscure, and separate from the global > #* controls > #channel_brightness > #channel_contrast > #channel_hue > #channel_saturation > > #* These options aren't supported and could be dangerous to > #* hardware!! See gatos.h and gatos.c from libgatos. > #format > #capturemode > #doublebuffer > #overclock > #cc > #tvtype > > #* Here are the different video sizes you can use in the > #* video section : (from gatos.h) > #* hactive_pal[] = {96,192,384,576,720,768} ; > #* vactive_pal[] = {72,144,288,432,540,576} ; > #* hactive_ntsc[] = {80,160,320,480,600,640} ; > #* vactive_ntsc[] = {60,120,240,360,450,480} ; > 152c197,198 < video_section video_v4l_bttv --- > video_section video_gatos > #video_section video_v4l_bttv diff -r -N camserv-0.42/configure.in camserv-0.42_max/configure.in 42,57d41 < AC_PATH_PROG(gnomeconfig, gnome-config) < AC_MSG_CHECKING(for gdk_pixbuf) < GDK_PIXBUF_CFLAGS=`$gnomeconfig gdk_pixbuf --cflags` < GDK_PIXBUF_LDFLAGS=`$gnomeconfig gdk_pixbuf --libs` < AM_CONDITIONAL(HAVE_GDK_PIXBUF, test "_$GDK_PIXBUF_CFLAGS" != _) < if test "_$GDK_PIXBUF_CFLAGS" = _ ; then < AC_MSG_RESULT([not found!]) < echo < echo "gdk_pixbuf is not installed on this system. You will be unable " < echo "to use the GDK Pixbuf filter" < echo < else < AC_MSG_RESULT(ok) < LIBS="$LIBS $GDK_PIXBUF_LDFLAGS $GNOME_LIBS" < CPPFLAGS="$CPPFLAGS $GDK_PIXBUF_CFLAGS" < fi 58a43,67 > AC_ARG_ENABLE(filter_gdk, > [ --disable-filter_gdk To turn off this filter], > [gdk_filter_flag="$enableval"], > [gdk_filter_flag=yes] > ) > if test "$gdk_filter_flag" = "yes"; then > AC_PATH_PROG(gnomeconfig, gnome-config) > AC_MSG_CHECKING(for gdk_pixbuf) > GDK_PIXBUF_CFLAGS=`$gnomeconfig gdk_pixbuf --cflags` > GDK_PIXBUF_LDFLAGS=`$gnomeconfig gdk_pixbuf --libs` > AM_CONDITIONAL(HAVE_GDK_PIXBUF, test "_$GDK_PIXBUF_CFLAGS" != _) > if test "_$GDK_PIXBUF_CFLAGS" = _ ; then > AC_MSG_RESULT([not found!]) > echo > echo "gdk_pixbuf is not installed on this system. You will be unable " > echo "to use the GDK Pixbuf filter" > echo > else > AC_MSG_RESULT(ok) > LIBS="$LIBS $GDK_PIXBUF_LDFLAGS $GNOME_LIBS" > CPPFLAGS="$CPPFLAGS $GDK_PIXBUF_CFLAGS" > fi > else > AM_CONDITIONAL(HAVE_GDK_PIXBUF, false) > fi 61,62c70,80 < AC_JPEG_VALID < AM_CONDITIONAL(JPEG_VALID, test $av_jpeg_valid = yes) --- > AC_ARG_ENABLE(jpegtest, > [ --disable-jpegtest If you know you have a current libjpeg ], > [test_jpeg_flag = "$enableval"], > [test_jpeg_flag = yes] ) > if test "$test_jpeg_flag" = "yes"; then > AC_JPEG_VALID > AM_CONDITIONAL(JPEG_VALID, test $av_jpeg_valid = yes) > else > AM_CONDITIONAL(JPEG_VALID, true) > av_jpeg_valid=yes > fi 85a104,107 > AC_CHECK_HEADERS(gatos/gatos.h, > [video_gatos=yes],[video_gatos=no]) > AM_CONDITIONAL(VIDEO_GATOS, test $video_gatos = yes) > 92a115,130 > fi > > if test $video_gatos = yes ; then > if test $av_jpeg_valid = no ; then > echo > echo "ATI/Gatos header was detected, but your JPEG library is " > echo "too old. Please upgrade to at least libjpeg version 6b" > echo "Neither the video library, nor the jpeg filter will be built" > echo > else > echo > echo "ATI/Gatos enabled. PLEASE make sure you configured ati-gatos" > echo " with the --enable-shared flag, and that libgatos.so.0 exists!" > echo > valid_video_inputs="$valid_video_inputs gatos" > fi