funcoesHAIRCAPTURE.cpp

Go to the documentation of this file.

// Autor: Alessandro de Oliveira Faria <alessandrofaria@netitec.com.br>
// http://www.netitec.com.br/alessandro

#include "funcoesHAIRCAPTURE.h"
#include "jpeg.c"

//****************************************************************************
// TYPE........: Function
// NAME........: TOSTRINGTCP
// SUMMARY.....: Convert the number type int/float to string.
// CREATED.....: 03/12/2004
// MODIFIED....: 06/02/2005
//****************************************************************************
std::string ToString(int Cnumero)
{
   char sz[101];
   sprintf(sz, "%d", Cnumero);
   std::string lreturn(sz);
   return lreturn;
}

std::string ToString(float Cnumero)
{
   char sz[101];
   sprintf(sz, "%G", Cnumero);
   std::string lreturn(sz);

   return lreturn;
}
//****************************************************************************
// TYPE........: Function
// NAME........: FileExist
// SUMMARY.....: Verify if file exist in disk.
// CREATED.....: 03/12/2004
// MODIFIED....: 06/02/2005
//****************************************************************************
bool FileExist(char *lcharFILE)
{
   bool lboolRETORNO = true;

   struct stat lstatFILE;

   if ( stat(lcharFILE,&lstatFILE))
   {
      lboolRETORNO = false;
      printf(" > File not exist! \n");
   }

   if(lstatFILE.st_size<=0)
   {
      lboolRETORNO = false;
      printf(" > File error!");
   }

   return lboolRETORNO;
}


//****************************************************************************
//!SUMMARY.....: Execute the Method Live
/* TYPE........: Function for thread
 * NAME........: ThreadAoVivo
 * CREATED.....: Jun-20-2005
 * MODIFIED....: Jul-01-2005
 *\param VIDEO pointer for CAPTURE class
 *****************************************************************************/
void *ThreadAoVivo(HAIR::CAPTURE *VIDEO)
{
  VIDEO->Live();
}
//****************************************************************************
//!SUMMARY.....: Limite saturation color
/*!TYPE........: Function for save frame jpeg
 * NAME........: Sat
 * CREATED.....: Nov-05-2005
 * MODIFIED....: Nov-11-2005
 *\param val Value color
 *****************************************************************************/
uchar SAT(int val) 
{

   if      (val <   0) return 0;
   else if (val > 255) return 255;
   return (uchar) val;
}
//****************************************************************************
//!SUMMARY.....: Feedback function for play mpeg
/*!TYPE........: Function 
 * NAME........: UPDATE
 * CREATED.....: Nov-05-2005
 * MODIFIED....: Nov-11-2005
 *\param screen Surface for display mpeg
 *\param x First position
 *\param y First positon
 *\param w Width of video
 *\param h height of video
 *****************************************************************************/
void update(SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h)
{
   SDL_UpdateRect(screen, x, y, w, h);
}

namespace HAIR
{
//****************************************************************************
// TYPE........: Method
// NAME........: PLAYMPEG
// SUMMARY.....: Show and play MPEG videoe
// CREATED.....: 07-Nov-2005
// MODIFIED....: 11-Nov-2005
// PARAMETERS..: 
//     char *name MPEG file name
//****************************************************************************
void CAPTURE::PlayMPEG(char *name)
{
   this->mpeg = SMPEG_new(name, &this->info, 1);
   SMPEG_setdisplay(this->mpeg,  this->video_surface, NULL, update);
   SMPEG_play(this->mpeg);
   this->UseVideo = true;
}

//****************************************************************************
// TYPE........: Method 
// NAME........: Live
// SUMMARY.....: Show Image
// CREATED.....: 01-Jul-2005
// MODIFIED....: 02-Jul-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::Live(void) 
{
   this->map_buffer.frame = 1;
   do 
   {
      if (-1 == ioctl(this->fd, VIDIOCMCAPTURE, &this->map_buffer)) 
      {
         printf(" > Error: Grabber chip can't sync (no station tuned in?)\n"); 
         exit(-1);
      }
   this->map_buffer.frame = !this->map_buffer.frame;
   
   if (-1 == ioctl(this->fd, VIDIOCSYNC, &this->map_buffer.frame)) 
   {
      printf(" > Error: on sync!\n"); 
      exit(-1);
   }
   this->WriteScreen(this->map+ this->buffers.offsets[this->map_buffer.frame]);
   SDL_PollEvent(&this->event);
   this->key = this->event.key.keysym.sym;
   } while ((this->event.type != SDL_KEYDOWN) || (this->key!=SDLK_q));
  
   SMPEG_delete(this->mpeg);
   SDL_Quit();


}

//****************************************************************************
// TYPE........: Method 
// NAME........: SetFont
// SUMMARY.....: Change Fonte TrueType
// CREATED.....: 20-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: char Font Name
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetFont(char *lfontName)
{
   this->fontName = lfontName;  
}

//****************************************************************************
// TYPE........: Method
// NAME........: SetSizeFont
// SUMMARY.....: Change Fonte Size
// CREATED.....: 24-Jan-2006
// MODIFIED....: 24-Jan-2006
// PARAMETERS..: int Size Font
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetFontSize(int lintSize)
{
   this->size_font = lintSize;

}

//****************************************************************************
// TYPE........: Method 
// NAME........: SetDevice
// SUMMARY.....: Change Video Device
// CREATED.....: 20-July-2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: char Name Device
//      COMMENT.....: none
//****************************************************************************
void CAPTURE::SetDevice(char *lDevice)
{
   this->device = lDevice;      
}

//****************************************************************************
// TYPE........: Method 
// NAME........: ColorBit
// SUMMARY.....: Change Bit Color Image
// CREATED.....: 20-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: Int Depth
// COMMENT.....: none
//****************************************************************************
void CAPTURE::ColorBit(int depth)
{
   this->depth = depth; 
}

//****************************************************************************
// TYPE........: Method 
// NAME........: Resolution
// SUMMARY.....: Change resolution 
// CREATED.....: 19-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: Int Width, Height
// COMMENT.....: none
//****************************************************************************
void CAPTURE::Resolution(int width, int height)
{
   this->width = width;
   this->height= height;
}


//****************************************************************************
// TYPE........: Method
// NAME........: Resolution
// SUMMARY.....: Change resolution window
// CREATED.....: 24-Jan-2006
// MODIFIED....: 01-Jan-2006
// PARAMETERS..: Int Width, Height
// COMMENT.....: none
//****************************************************************************
void CAPTURE::ResolutionWin(int width, int height)
{
   this->widthWin  = width;
   this->heightWin = height;
}

//****************************************************************************
// TYPE........: Method
// NAME........: SetAngleText
// SUMMARY.....: Change the angle for rotation text surface
// CREATED.....: 24-Jan-2006
// MODIFIED....: 24-Jan-2006
// PARAMETERS..: Int Angle
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetAngleText(int lintAngle)
{
   this->RotateText  = lintAngle;
}


//****************************************************************************
// TYPE........: Method
// NAME........: SetAngleVideo
// SUMMARY.....: Change the angle for rotation video surface
// CREATED.....: 24-Aug-2006
// MODIFIED....: 24-Aug-2006
// PARAMETERS..: Int Angle
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetAngleVideo(int lintAngle)
{
   this->RotateVideo  = lintAngle;
}




//****************************************************************************
// TYPE........: Method
// NAME........: SetVideoPos
// SUMMARY.....: Change the position of window video live
// CREATED.....: 24-Jan-2006
// MODIFIED....: 24-Jan-2006
// PARAMETERS..: Int Width, Height
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetVideoPos(int x, int y)
{
   this->top  = y;
   this->left = x;
}


//****************************************************************************
// TYPE........: Method 
// NAME........: convertYUV420PtoGray
// SUMMARY.....: Convert map image YUV to Gray
// CREATED.....: 27-Mar-2006
// MODIFIED....: 27-Mar-2006
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::convertYUV420PtoGray(void) 
{
   unsigned int gray;
   unsigned long len = (this->width*this->height*3)>> 2;
   unsigned char *src = this->v4l_convert_buf;
   unsigned char *dst = this->last_map;
   while(len--)
   {
      gray = src[0]+src[1]+src[2];
      dst[0]=dst[1]=dst[2]=gray/4;

      src += 4;
      dst += 4;

   }
   
   if (this->debug)
   printf(" > Convert to GrayScale.\n");
}
 
//****************************************************************************
// TYPE........: Method 
// NAME........: convertYUV420PtoRGB
// SUMMARY.....: Convert map image YUV to RGB
// CREATED.....: 06-June2005
// MODIFIED....: 02-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::convertYUV420PtoRGB(bool forDISK) 
{
   unsigned char *y, *u, *v, *r, *g, *b;
   int tmp,i;
   // Convert if format same YUV
   if (this->map_buffer.format==VIDEO_PALETTE_YUV420P) 
   {
        r=this->v4l_convert_buf;
        g=this->v4l_convert_buf+1;
        b=this->v4l_convert_buf+2;
        if (this->debug)
        printf(" > Convert YUV to RGB for video live.\n");
     y=this->map;

      u=y+this->width*this->height;
      v=y+this->width*this->height+(this->width*this->height)/4;
      for (i=0; i<this->width*this->height; i++) 
      {
         tmp=(((int)*y-16)*76284 + 104595*((int)*u-128)) >>16;
         if (tmp<0) tmp=0; if (tmp>255) tmp=255;
         *b=tmp;
         tmp=(((int)*y-16)*76284 - 53281*((int)*u-128) - 25625*((int)*v-128)) >>16;
         if (tmp<0) tmp=0; if (tmp>255) tmp=255;
         *g=tmp;
         tmp=(((int)*y-16)*76284 + 132252*((int)*v-128)) >>16;
         if (tmp<0) tmp=0; if (tmp>255) tmp=255;
         *r=tmp;
         if (i & 1) 
         {
            u++;
            v++;
         }
         if (i%(this->width*2)==this->width-1) 
         {
            u-=this->width/2;
            v-=this->width/2;
         }
         r+=3;
         g+=3;
         b+=3;
         y++;
      }
   }

}

//****************************************************************************
// TYPE........: Method
// NAME........: converttoRGB
// SUMMARY.....: Convert map image to RGB
// CREATED.....: Nov-21-2005
// MODIFIED....: Nov-21-2005
//****************************************************************************
void CAPTURE::swap_rgb24(void) 
{
   this->v4l_convert_buf = this->map;

   //this->last_map = this->v4l_convert_buf;
   /*unsigned char  c;
   unsigned char *p = this->v4l_convert_buf;
   int   i = (this->width*this->height) ;
   while (--i) 
   {
      c = p[0];
      p[0] = p[2];
      p[2] = c;
      p += 3;
   }*/
   //this->last_map = this->map;

}



//****************************************************************************
// TYPE........: Method 
// NAME........: SavePPM
// SUMMARY.....: Save frame in format PPM Portable Pixel Map
// CREATED.....: 20-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: char File Name 
// COMMENT.....: none
//****************************************************************************
bool CAPTURE::SaveJPG(char *name,bool lboolFRAMEGRAY) 
{
   bool lboolreturn = false;

 unlink(name);

   if (this->map_buffer.format==VIDEO_PALETTE_YUV420P)
   {
      this->convertYUV420PtoRGB(true);
   }
   else
      swap_rgb24();

   int   quality = 75;
   imageRGB img;
   img.data   =  this->v4l_convert_buf; //(unsigned char*)this->offscreen->pixels; // 

   img.width  = this->width;
   img.height = this->height;

   // adjust colors
   int w, h;
   for (w = 0; w < img.width; w++) 
   {
      for (h = 0; h < img.height; h++) 
      {
         uchar* pixel = &img.data[3*(w + img.width*h)];
         pixel[0] = SAT(pixel[0]+10);  // more RED
         pixel[1] = pixel[1];          // no change in GREEN
         pixel[2] = SAT(pixel[2]-10);  // less BLUE
      }
   }

  lboolreturn = write_JPEG_file (name, quality, img);

  if (this->debug)
  printf(" > SaveJPG(%s,%d)\n", name,lboolFRAMEGRAY);

  lboolreturn = FileExist(name);
  
  return lboolreturn;


}


//****************************************************************************
// TYPE........: Method
// NAME........: LoadJPEG
// SUMMARY.....: Load frame in format JPEG
// CREATED.....: 15-Nov-2005
// MODIFIED....: 15-Nov-2005
// PARAMETERS..: char File Name
// COMMENT.....: none
//****************************************************************************
void CAPTURE::LoadJPG(char *name,int lintX, int lintY, float lfloatSCALE, TypeSurface lsurfaceScreen, int lintAngleRotate )
{

   SDL_Surface *LimageLarge;
   SDL_Surface *LimageSmall;

   SDL_RWops *rwop;
   rwop=SDL_RWFromFile(name, "rb");

   if (this->debug)
   printf(" > LoadJPG ...");
   LimageLarge=IMG_LoadJPG_RW(rwop);
   if(!LimageLarge) 
   {
      printf(" > IMG_LoadJPG_RW: %s\n", IMG_GetError());
   }
  
   if (this->debug)
   printf(" OK!\n");
  
   LimageSmall = zoomSurface(LimageLarge, lfloatSCALE,lfloatSCALE, 1);

   this->TempRect.x = lintX;
   this->TempRect.y = lintY;
   this->TempRect.w = LimageSmall->w;
   this->TempRect.h = LimageSmall->h;

   if(lintAngleRotate!=0)
   {
         LimageSmall = rotozoomSurface(LimageSmall, lintAngleRotate, 1,SMOOTHING_ON);
         this->TempRect.w = LimageSmall->h;
         this->TempRect.h = LimageSmall->w;
   }


   switch(lsurfaceScreen)
   {

   case TEXTS:
      {
         SDL_BlitSurface(LimageSmall, NULL, this->text_surface, &TempRect);
         SDL_UpdateRect(this->text_surface, 0, 0, 0, 0);
         this->UseText = true;
         break; 
      }
   case DRAW:
      {
         SDL_BlitSurface(LimageSmall, NULL, this->draw_surface, &TempRect);
         SDL_UpdateRect(this->draw_surface, 0, 0, 0, 0);
         this->UseDraw = true;
         break;
      }

   case ZOOM:
      {
         SDL_BlitSurface(LimageSmall, NULL, this->zoomout_surface, &TempRect);
         SDL_UpdateRect(this->zoomout_surface, 0, 0, 0, 0);
         this->UseZoomOut = true;
         break;
      }
   case VIDEO:
      {
         SDL_BlitSurface(LimageSmall, NULL, this->video_surface, &TempRect);
         SDL_UpdateRect(this->video_surface, 0, 0, 0, 0);
         this->UseVideo = true;
         break;
      }

   }

   SDL_FreeSurface(LimageSmall);
   SDL_FreeSurface(LimageLarge);

   if (this->debug)
   printf(" > LoadJPG(%s,%d,%d,%f,%d)\n", name,lintX, lintY, lfloatSCALE,lsurfaceScreen);
}



//****************************************************************************
// TYPE........: Method
// NAME........: Background
// SUMMARY.....: Load and define JPEG background
// CREATED.....: 24-Jan-2006
// MODIFIED....: 24-Jan-2006
// PARAMETERS..: char File Name
// COMMENT.....: none
//****************************************************************************
void CAPTURE::Background(char *name)
{

   SDL_Surface *LimageLarge;

   SDL_RWops *rwop;
   rwop=SDL_RWFromFile(name, "rb");

   LimageLarge = IMG_LoadJPG_RW(rwop);
  
   if(!LimageLarge)
   {
      printf(" > IMG_LoadJPG_RW: %s\n", IMG_GetError());
   }
     SDL_BlitSurface(LimageLarge, NULL, this->screen, NULL);
     SDL_UpdateRect(this->screen, 0, 0, 0, 0);

}

//****************************************************************************
// TYPE........: Method
// NAME........: VIEWLASTMAP
// SUMMARY.....: Display last frame saved
// CREATED.....: 15-Nov-2005
// MODIFIED....: 15-Nov-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::ViewLastMap(int lintX, int lintY, float lfloatSCALE, TypeSurface lsurfaceScreen)
{
   SDL_Surface *LimageSmall;
   SDL_Surface *LimageLarge;
   
   if(this->debug)
   printf(" > Starting ViewLastMap.\n");


   LimageLarge = SDL_CreateRGBSurfaceFrom((void *)  this->last_map, this->width, this->height, this->depth,  this->width*3, 0xFF0000, 0x00FF00, 0x0000FF, 0x000000);


   LimageSmall = zoomSurface(LimageLarge, lfloatSCALE,lfloatSCALE, 1);

   this->TempRectImage.x = lintX;
   this->TempRectImage.y = lintY;
   this->TempRectImage.w = LimageSmall->w;
   this->TempRectImage.h = LimageSmall->h;

   switch(lsurfaceScreen)
   {

   case TEXTS:
      {
         this->UseText = false;
         SDL_BlitSurface(LimageSmall, NULL, this->text_surface, &TempRectImage);
         SDL_UpdateRect(this->text_surface, 0, 0, 0, 0);
         this->UseText = true;
         break; 
      }
   case DRAW:
      {
         this->UseDraw = false;
       SDL_BlitSurface(LimageSmall, NULL, this->draw_surface, &TempRectImage);
         SDL_UpdateRect(this->draw_surface, 0, 0, 0, 0);
         this->UseDraw = true;
         break;
      }

   case ZOOM:
      {
         this->UseZoomOut = false;
         SDL_BlitSurface(LimageSmall, NULL, this->zoomout_surface, &TempRectImage);
         SDL_UpdateRect(this->zoomout_surface, 0, 0, 0, 0);
         this->UseZoomOut = true;
         break;
      }
   case VIDEO:
      {
         this->UseVideo = false;
         SDL_BlitSurface(LimageSmall, NULL, this->video_surface, &TempRectImage);
         SDL_UpdateRect(this->video_surface, 0, 0, 0, 0);
         this->UseVideo = true;
         break;
      }

   }

   SDL_FreeSurface(LimageSmall);
   SDL_FreeSurface(LimageLarge);

   if(this->debug)
   printf(" > Finishing ViewLastMap.\n");



}


//****************************************************************************
// TYPE........: Method 
// NAME........: SavePPM
// SUMMARY.....: Save frame in format PPM Portable Pixel Map
// CREATED.....: 20-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: char File Name 
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SavePPM(char *name) 
{
   int i=0;
   FILE *fp;

   this->convertYUV420PtoRGB(true);
   sprintf (this->arqPPM, "P6 %d %d 255 ", this->width, this->height);

   for (i=0; i<(this->width*this->height*3); i++) 
      this->arqPPM[i+15] = this->v4l_convert_buf[i];

   if ((fp=fopen(name, "w+")) == NULL) 
   {
      printf(" > Error: write image PPM!");
      exit(-1);
   }
   fwrite ((char*)this->arqPPM, (this->width*this->height * 3)+15, 1, fp);
   fclose (fp);
}

//****************************************************************************
// TYPE........: Method 
// NAME........: WriteScreen
// SUMMARY.....: Wrtie image in Video
// CREATED.....: 30-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: unsigned char Map Image
// COMMENT.....: none
//****************************************************************************
void CAPTURE::WriteScreen(unsigned char* tmap) 
{
    int lintLoop = 0;
        
   // Convert palette for RGB
   if (this->map_buffer.format==VIDEO_PALETTE_YUV420P) 
   {
      unsigned int sizeY = this->width * this->height;
      unsigned int sizeUV = (this->width /2)* ( this->height / 2 );

      this->offscreen = SDL_CreateRGBSurface(SDL_HWSURFACE | SDL_DOUBLEBUF, this->width, this->height, this->depth, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);

      this->offscreenOVL = SDL_CreateYUVOverlay (this->width , this->height ,SDL_IYUV_OVERLAY,this->offscreen );

      SDL_LockYUVOverlay (this->offscreenOVL) ;

      memcpy( this-> offscreenOVL->pixels[ 0 ] , tmap , sizeY ) ;
      memcpy( this-> offscreenOVL->pixels[ 1 ] , tmap+sizeY , sizeUV ) ;
      memcpy( this->offscreenOVL->pixels[ 2 ] , tmap+sizeY+sizeUV , sizeUV ) ;

      SDL_UnlockYUVOverlay ( this->offscreenOVL ) ;
      this->TempRect.x = 0;
      this->TempRect.y = 0;
      this->TempRect.w = this->width ;
      this->TempRect.h = this->height ;
      SDL_DisplayYUVOverlay( this->offscreenOVL,&this->TempRect) ;
   }    
   else
   {
      this->offscreen = SDL_CreateRGBSurfaceFrom((void *) tmap, this->width, this->height, this->depth,  this->width*3, 0xFF0000, 0x00FF00, 0x0000FF, 0x000000);
   }
   this->TempRect.y = this->top;
   this->TempRect.x = this->left;

   if(this->RotateVideo!=0)
   {
         this->offscreen = rotozoomSurface(this->offscreen, this->RotateVideo, 1,SMOOTHING_ON);
         this->TempRect.w = this->height;
         this->TempRect.h = this->width;
   }


   //SDL_BlitSurface(this->offscreen, NULL, this->screen, NULL);
   SDL_BlitSurface(this->offscreen, NULL, this->screen, &this->TempRect);

   this->TempRect.x = this->left;
   this->TempRect.y = this->top;

   if(this->UseZoomOut)
   {
      //SDL_LockSurface( this->zoomout_surface);
      SDL_BlitSurface( this->zoomout_surface, NULL, this->screen, &this->TempRect);
      //SDL_UnlockSurface( this->zoomout_surface);
   }

   if(this->UseVideo)
   {  
      //SDL_LockSurface( this->video_surface);
      this->TempRect.y = this->top;
      this->TempRect.x = this->left+(this->width/2)+1;
      SDL_BlitSurface(this->video_surface, NULL, this->screen, &this->TempRect);
      if(SMPEG_status(this->mpeg) != SMPEG_PLAYING)
      {
         SMPEG_stop(this->mpeg);
         SMPEG_delete(this->mpeg);
         ClearSurface(VIDEO);
      }
      //SDL_UnlockSurface( this->video_surface);
   }

   this->TempRect.x = 0;
   if(this->GrabZoom)
   { 
      this->GrabZoom = false;
      this->ZoomOut(true);
   }


   if(this->UseDraw)
   {
      //SDL_LockSurface( this->draw_surface);
      SDL_BlitSurface( this->draw_surface, NULL, this->screen, NULL);
      //SDL_UnlockSurface( this->draw_surface);
   }

   if(this->UseText)
   {
      //SDL_LockSurface( this->text_surface);
      SDL_BlitSurface( this->text_surface,NULL,this->screen,NULL);
      //SDL_UnlockSurface( this->text_surface);
   }
 
   SDL_UpdateRect(this->screen, 0, 0, 0, 0);

 do
 {
      SDL_PollEvent(&this->event);
         if ((this->event.type == SDL_MOUSEBUTTONDOWN)) 
         {
            if((lintTouchX != this->event.motion.x) || (lintTouchY != this->event.motion.y))
            {
               if(this->debug)
               printf(" > Mouse pointer X:%d , Y:%d \n", this->event.motion.x, this->event.motion.y);

               lintTouchX = this->event.motion.x;
               lintTouchY = this->event.motion.y;
               if(this->ScanButtons)
               {
                  SDL_LockMutex(this->mutex);
                  this->LastButton = FindButton(this->event.motion.x, this->event.motion.y);

                  SDL_CondSignal(this->cond);
                  SDL_UnlockMutex(this->mutex);
               }
            }
         }


      if (this->event.type == SDL_KEYDOWN) 
      {

         this->key = this->event.key.keysym.sym;
         // Key SPACE: ZoomOut On
         if(this->key==this->KeyZoomOutOn)
         this->ZoomOut(true);

         if(this->key==this->KeyVideoOn)
         this->PlayMPEG(this->mpegName);

         // Key C: ZoomOut Off
         if(this->key==KeyZoomOutOff) 
         {  
            ClearSurface(TEXTS);
            ClearSurface(ZOOM);
            //this->ZoomOut(false);
         }
         // Key F: Fullscreen On/Off
         if(this->key==KeyFullScreeen)
         SDL_WM_ToggleFullScreen(this->screen);

         // Key S: Save screenshot : screenshot.ppm
         if(this->key==KeySaveFrame)
         this->SavePPM("screenshot.ppm");

         if(this->key == SDLK_RIGHT)
         {  
            AdjustVideo(+1);       
         }

         if(this->key == SDLK_LEFT)
         {  
            AdjustVideo(-1);
         }

         if(this->key == SDLK_UP)
         {  
            SelectAdjust(+1);
         }

         if(this->key == SDLK_DOWN)
         {  
            SelectAdjust(-1);
         }

         if((this->key>= SDLK_0) && (this->key<= SDLK_9) && (this->Lastkey!=this->key))
         { 
            this->Lastkey=this->key;
            this->SetInputCamera(this->key-SDLK_0,VIDEO_MODE_NTSC);
            ioctl(this->fd, VIDIOCSCHAN,&this->vch);
            if(this->debug)
            printf(" > Source %d selected\n",(this->key-SDLK_0)); 
         }



         // Key Q: Quit 
         if(this->key==KeyQuit)
         {
            this->VideoTerminate();
         }
      }


 } while(lintLoop++<10);

   if (this->map_buffer.format==VIDEO_PALETTE_YUV420P)
   SDL_FreeYUVOverlay(this->offscreenOVL);

   SDL_FreeSurface(this->offscreen);

}

//****************************************************************************
// TYPE........: Method
// NAME........: Open
// SUMMARY.....: Inicialize VideoCapture
// CREATED.....: 03-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::Open(void) 
{
   if (-1 == (this->fd = open(this->device, O_RDWR))) 
   {
      printf(" > Error: opening device: %s\n", this->device);
      exit(-1);
   }

   if (-1 == ioctl(this->fd,VIDIOCGCAP,&this->capability)) 
   {
      printf(" > Error: ioctl(fd,VIDIOCGCAP,&capability)\n");
      exit(-1);
   }
  
   if (this->debug) 
   {

      printf(" _   _    _    ___ ____   ____    _    ____ _____ _   _ ____  _____ \n");
      printf("| | | |  / \\  |_ _|  _ \\ / ___|  / \\  |  _ \\_   _| | | |  _ \\| ____|\n");
      printf("| |_| | / _ \\  | || |_) | |     / _ \\ | |_) || | | | | | |_) |  _|  \n");
      printf("|  _  |/ ___ \\ | ||  _ <| |___ / ___ \\|  __/ | | | |_| |  _ <| |___ \n");
      printf("|_| |_/_/   \\_\\___|_| \\_\\\\____/_/   \\_\\_|    |_|  \\___/|_| \\_\\_____|\n");

      printf(" >  \n");
      printf(" > V4L function VIDIOCGCAP.\n");
      printf(" > Name             : %s\n", &this->capability.name);
      printf(" > Channels         : %i\n", this->capability.channels);
      printf(" > Audios           : %i\n", this->capability.audios);
      printf(" > Maxwidth         : %i\n", this->capability.maxwidth);
      printf(" > Maxheight        : %i\n", this->capability.maxheight);
      printf(" > Minwidth         : %i\n", this->capability.minwidth);
      printf(" > Minheight        : %i\n", this->capability.minheight);
   }

   if (-1==ioctl(this->fd,VIDIOCGFBUF,&this->fbuffers))
   {
      printf(" > ERRO: V4L function VIDIOCGFBUF.\n");
   }
   else 
   {
      if (-1==ioctl(this->fd,VIDIOCSFBUF,&this->fbuffers)) 
      {
         printf(" > ERRO: V4L function VIDIOCSFBUF.\n");
      }
      else
      { 
         if (this->debug) 
         {
            printf (" > V4L function VIDIOCSFBUF.\n");
            printf (" > Add           : %d\n",  this->fbuffers.base);
            printf (" > Height        : %d\n",  this->fbuffers.height);
            printf (" > Width         : %d\n",  this->fbuffers.width);
            printf (" > Depth         : %d\n",  this->fbuffers.depth);
            printf (" > BPL           : %d\n",  this->fbuffers.bytesperline);
         }
      }
   }

   if (-1==ioctl(this->fd,VIDIOCGWIN,&this->videowin))
   {
      printf(" > ERRO: V4L function VIDIOCGWIN.\n");
   }
   else
   {
      videowin.x = 0;
      videowin.y = 0;
      videowin.width = this->width;
      videowin.height = this->height;
      videowin.clipcount = 0;
      videowin.chromakey = 1;
      videowin.flags = VIDEO_CLIPMAP_SIZE;

      if (-1==ioctl(this->fd,VIDIOCSWIN,&this->videowin))
      {
         printf(" > ERRO: V4L function VIDIOCSWIN.\n");
      }
   }

   if(-1 == ioctl(this->fd, VIDIOCGCHAN,&this->vch)) 
   {
      printf(" > ERRO: V4L function VIDIOCGCHAN.\n");
      exit(-1);
   }
   else
   {
      this->vch.norm = this->lintVideoMode;
      this->vch.tuners = this->llongTuners;

      if(-1 == ioctl(this->fd, VIDIOCSCHAN,&this->vch)) 
      {
         printf(" > ERRO: V4L function VIDIOCSCHAN.\n");
         exit(-1);
      }
      else
      {

         if(this->debug)
         {
            printf(" > V4L function VIDIOCSCHAN.\n");
            printf(" > Name           : %s\n", this->vch.name);
            printf(" > Channel        : %i\n", this->vch.channel);
            printf(" > Tuners         : %i\n", this->vch.tuners);
            printf(" > Flags          : %i\n", this->vch.flags);
            printf(" > Type           : %i\n", this->vch.type);
            printf(" > Norm           : %i\n", this->vch.norm);
         }
      }

   }

  if(this->map_buffer.format == 0)
  {
      if(!strcmp(this->vch.name,"Webcam"))
      {
         this->SetHardwareWebCam();
      }  
      else
      {
         this->SetHardwareCaptureCard();

      }  

  }




   if(-1 == ioctl(this->fd, VIDIOCGTUNER,&this->vtuner))
   {
      printf(" > ERRO: V4L function VIDIOCGTUNER.\n");
   }
   else
   {
      if(-1 == ioctl(this->fd, VIDIOCSTUNER,&this->vtuner))
      {
         printf(" > ERRO: V4L function VIDIOCSTUNER.\n");
      }
      else
      {

         if(this->debug)
         {
            printf(" > V4L function VIDIOCSTUNER.\n");
            printf(" > Tuner          : %i\n", this->vtuner.tuner);
            printf(" > Name           : %s\n", this->vtuner.name);
            printf(" > Low frequency  : %i\n", this->vtuner.rangelow);
            printf(" > High frequency : %i\n", this->vtuner.rangehigh);
            printf(" > Flags          : %i\n", this->vtuner.flags);
            printf(" > Mode           : %i\n", this->vtuner.mode);
            printf(" > Signal         : %i\n", this->vtuner.signal);
         }
      }

   }



   if (-1==ioctl( this->fd, VIDIOCGPICT, &this->pic ))
   {
      printf(" > ERRO: V4L function VIDIOCGPICT.\n");
   }
   else
   {
      this->pic.palette = this->lintVideoFormat;
      this->pic.depth   = this->depth;

      if (-1==ioctl( this->fd, VIDIOCSPICT, &this->pic ))
      {
         printf(" > ERRO: V4L function VIDIOCSPICT.\n");
      }
      else
      {
         if (this->debug) 
         {
            printf(" > V4L function VIDIOCSPICT.\n");
            printf(" > Brightness        : %d \n", this->pic.brightness/256 );
            printf(" > Hue               : %d\n", this->pic.hue/256);
            printf(" > Colour            : %d\n", this->pic.colour/256 );
            printf(" > Contrast          : %d \n", this->pic.contrast/256 );
            printf(" > Whiteness         : %d\n", this->pic.whiteness/256 );
            printf(" > Depth             : %d\n", this->pic.depth );
            printf(" > Palette           : %d \n", this->pic.palette );

        } 
     }
   }
   if(this->AudioEnabled)
   {
      if (-1 == ioctl(this->fd,VIDIOCGAUDIO, &this->audio)) 
      { 
         printf(" > ERRO: V4L function VIDIOCGAUDIO.\n");
      }
      else
      {
         this->audio.flags  = VIDEO_AUDIO_VOLUME;
         this->audio.volume = 30000;
         if (-1 == ioctl(this->fd,VIDIOCSAUDIO, &this->audio)) 
         { 
            printf(" > ERRO: V4L function VIDIOCSAUDIO.\n");    
         }
      }
   }
  
   //fcntl(fd,F_SETFD,FD_CLOEXEC);
   if (-1 == ioctl(this->fd,VIDIOCGMBUF,&this->buffers)) 
   {
      printf(" > ERRO: V4L function VIDIOCGMBUF.\n");
      exit(-1);
   }

  
   if (this->debug) 
   {
      printf(" > V4L function VIDIOCGMBUF.\n");
      printf(" > Size          : %d\n",this->buffers.size);
      printf(" > Frames        : %d\n",this->buffers.frames);
   }
                
   this->map = (unsigned char *)mmap(0,buffers.size,PROT_READ|PROT_WRITE,MAP_SHARED,this->fd,0);    
   if (this->map == NULL) 
   {
      printf(" > ERRO: Mmap is NULL.\n");
      exit(-1);
   }
   this->last_map = (unsigned char *)malloc(this->buffers.size);        
   this->v4l_convert_buf = (unsigned char *)malloc(this->buffers.size); 
   this->arqPPM = (char *)malloc((this->width*this->height*3)+15);
        
   this->map_buffer.width = this->width;
   this->map_buffer.height = this->height;
   this->map_buffer.format = this->pic.palette; 
   this->map_buffer.frame = 0;
   if (-1 == ioctl(this->fd, VIDIOCMCAPTURE, &map_buffer)) 
   { 
      printf(" > ERRO: Grabber chip error sync.\n");
      exit(-1);
   }

   if (this->debug)
   {
      printf(" > V4L function VIDIOCMCAPTURE.\n");
      printf(" > Width         : %d\n",this->map_buffer.width);
      printf(" > Height        : %d\n",this->map_buffer.height);
      printf(" > Format        : %d\n",this->map_buffer.format);
      printf(" > Frame         : %d\n",this->map_buffer.frame);
   }

}

//****************************************************************************
// TYPE........: Method
// NAME........: VideoCreate
// SUMMARY.....: Inicialize VideoCapture
// CREATED.....: 09-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::VideoCreate(void)
{
   this->Open();

}


//****************************************************************************
// TYPE........: Method
// NAME........: InitVideo
// SUMMARY.....: Inicialize Video
// CREATED.....: 09-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::VideoTerminate(void)
{
   if(this->AudioEnabled)
   {
      this->audio.flags  = VIDEO_AUDIO_MUTE;
      this->audio.volume = 0;
      ioctl(this->fd,VIDIOCSAUDIO, &this->audio);
   }
   close(this->fd);
   SDL_Quit();
   exit(0);

}


//****************************************************************************
// TYPE........: Method
// NAME........: InicializeWin
// SUMMARY.....: Inicialize Video
// CREATED.....: 09-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::InicializeWin(void) 
{
   SDL_Init(SDL_INIT_VIDEO );
        
//   this->screen = SDL_SetVideoMode(this->width, this->height, this->depth, 
//                                   SDL_HWSURFACE | SDL_DOUBLEBUF);
   this->screen = SDL_SetVideoMode(this->widthWin, this->heightWin, this->depth,  
   SDL_HWSURFACE);
        
   if ( this->screen == NULL ) 
   {
      fprintf(stderr, " > SDL Error: Couldn't set %dx%d video mode: %s\n",
                       this->width,this->height, SDL_GetError());
      exit(-1);
   }
   SDL_WM_SetCaption("NETi TECNOLOGIA", NULL);
   this->TempRect.x = 0;
   this->TempRect.y = 0;
   this->TempRect.w = this->widthWin;
   this->TempRect.h = this->heightWin;

   printf( " > SDL Created %dx%d with %d color Surface Draw.\n",this->width, this->height,this->depth);
        
   this->draw_surface = SDL_CreateRGBSurface(SDL_HWSURFACE | SDL_DOUBLEBUF, 
                                             this->widthWin, this->heightWin, this->depth, 
                                             screen->format->Rmask, screen->format->Gmask, 
                                             screen->format->Bmask, screen->format->Amask);
   this->colorTransparent = SDL_MapRGB(this->draw_surface->format,SRCcolorTransparent.r,
                                       SRCcolorTransparent.g,SRCcolorTransparent.b);

   SDL_SetColorKey(this->draw_surface,SDL_SRCCOLORKEY,this->colorTransparent);
   SDL_FillRect(this->draw_surface,&this->TempRect, this->colorTransparent);

   this->text_surface = SDL_CreateRGBSurface(SDL_HWSURFACE | SDL_DOUBLEBUF,
                                             this->widthWin, this->heightWin, this->depth,
                                             screen->format->Rmask, screen->format->Gmask,
                                             screen->format->Bmask, screen->format->Amask);  
   SDL_SetColorKey(this->text_surface,SDL_SRCCOLORKEY,this->colorTransparent);
   SDL_FillRect(this->text_surface,&this->TempRect, this->colorTransparent);

   this->TempRect.w = this->width/2;
   this->TempRect.h = this->height/2;

   // Create surface MPEG video
   this->video_surface = SDL_CreateRGBSurface(SDL_HWSURFACE | SDL_DOUBLEBUF, 
                                              this->TempRect.w, this->TempRect.h, this->depth, 
                                              screen->format->Rmask, screen->format->Gmask, 
                                              screen->format->Bmask, screen->format->Amask);
   SDL_SetColorKey( this->video_surface,SDL_SRCCOLORKEY,this->colorTransparent);
   SDL_FillRect(this->video_surface,&this->TempRect, this->colorTransparent);


   this->TempRect.w = this->width;
   this->TempRect.h = this->height;


   // Create surface ZoomOut
   this->zoomout_surface = SDL_CreateRGBSurface(SDL_HWSURFACE | SDL_DOUBLEBUF, 
                                                this->TempRect.w, this->TempRect.h, this->depth, 
                                                screen->format->Rmask, screen->format->Gmask, 
                                                screen->format->Bmask, screen->format->Amask);
   SDL_SetColorKey( this->zoomout_surface,SDL_SRCCOLORKEY,this->colorTransparent);
   SDL_FillRect(this->zoomout_surface,&this->TempRect, this->colorTransparent);
}



//***************************************************************************
// TYPE........: Method
// NAME........: ClearSurface
// SUMMARY.....: Clear surface 
// CREATED.....: 11-Nov-2005
// MODIFIED....: 18-Mar-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::ClearSurface(TypeSurface lsurfaceScreen ,bool lboolSurface)
{
   this->TempRect.x = 1;
   this->TempRect.y = 1;

   switch(lsurfaceScreen)
   {
   case DRAW:
      {  this->UseDraw = lboolSurface;
         this->TempRect.w = this->draw_surface->w;
         this->TempRect.h = this->draw_surface->h;
         SDL_FillRect(this->draw_surface,&this->TempRect, this->colorTransparent);
         break;
      }
   case TEXTS:
      {  this->UseText = lboolSurface;
         this->TempRect.w = this->text_surface->w;
         this->TempRect.h = this->text_surface->h;
         SDL_FillRect(this->text_surface,&this->TempRect, this->colorTransparent);
         break;
      }
  case ZOOM:
      {  this->UseZoomOut = lboolSurface;
         this->TempRect.w = this->zoomout_surface->w;
         this->TempRect.h = this->zoomout_surface->h;
         SDL_FillRect(this->zoomout_surface,&this->TempRect, this->colorTransparent);
         break;
      }
   case VIDEO:
      {  this->UseVideo = lboolSurface;
         this->TempRect.w = this->video_surface->w;
         this->TempRect.h = this->video_surface->h;
         SDL_FillRect(this->video_surface,&this->TempRect, this->colorTransparent);
         break;
      }


   }
}

//***************************************************************************
// TYPE........: Method
// NAME........: ClearSurface
// SUMMARY.....: Clear surface 
// CREATED.....: 11-Fev-2006
// MODIFIED....: 11-Fev-2006
// PARAMETERS..: SDL_Surface *lsurfaceScreen
// COMMENT.....: none
//****************************************************************************
void CAPTURE::ClearSurface(TypeSurface lsurfaceScreen ,int lintX, int lintY, int lintW, int lintH)
{
   this->TempRect.x = lintX;
   this->TempRect.y = lintY;

   switch(lsurfaceScreen)
   {
   case VIDEO:
      {  
         this->TempRect.w = lintW;
         this->TempRect.h = lintH;
         SDL_FillRect(this->video_surface,&this->TempRect, this->colorTransparent);
         break;
      }  
   case TEXTS:
      {  
         this->TempRect.w = lintW;
         this->TempRect.h = lintH;
         SDL_FillRect(this->text_surface,&this->TempRect, this->colorTransparent);
         break;
      }
   case DRAW:
      {  
         this->TempRect.w = lintW;
         this->TempRect.h = lintH;
         SDL_FillRect(this->draw_surface,&this->TempRect, this->colorTransparent);
         break;
      }
  case ZOOM:
      {  
         this->TempRect.w = lintW;
         this->TempRect.h = lintH;
         SDL_FillRect(this->zoomout_surface,&this->TempRect, this->colorTransparent);
         break;
      }


   }
}


//****************************************************************************
// TYPE........: Method
// NAME........: Show
// SUMMARY.....: Show Live Video (thread)
// CREATED.....: 09-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::Show(void) 
{
   this->thread = new pthread_t();
   if (pthread_create(this->thread, NULL,  (void *(*)(void *))ThreadAoVivo, this)) 
   {
      printf(" > Error: creating the first thread\n");
      exit(-1);
   }

   if (this->debug) 
   {
      printf(" > Result of MultThread.\n");
      printf(" > Thread ok!\n");
   }
}

//****************************************************************************
// TYPE........: Method
// NAME........: VideoInicialize
// SUMMARY.....: Show Live Video (thread)
// CREATED.....: 09-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::VideoInicialize(void)
{
    this->Show();
}

//****************************************************************************
// TYPE........: Method
// NAME........: WaitForVideo
// SUMMARY.....: Wait for thresd Live
// CREATED.....: 29-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::WaitForVideo(void) 
{
   pthread_join(*this->thread, 0);
}

//****************************************************************************
// TYPE........: Method
// NAME........: WaitText
// SUMMARY.....: Write text over video
// CREATED.....: 15-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::WriteText(int lintx, int linty, char *lcharText,int lintSIZE, bool lboolSHADOW) 
{ 
   this->UseText = false;

   if (this->debug) 
   {
      printf(" > WriteText(%d,%d,%s,%d,%d)\n",lintx, linty, lcharText,lintSIZE,lboolSHADOW);
   }
        
   TTF_Init();
   SDL_Surface *Limage;  
   SDL_Surface *LimageShadow;
   SDL_Surface *LimageR;

   int intTMPR, intTMPG, intTMPB;


   this->NameFont= TTF_OpenFont( this->fontName,lintSIZE);
   TTF_SetFontStyle(this->NameFont, TTF_STYLE_NORMAL);

   if(lboolSHADOW)
   {
      //intTMPR = this->colorFont.r;
      //intTMPG = this->colorFont.g;
      //intTMPB = this->colorFont.b;

      //this->SetColorFont(1,1,1);
      LimageShadow = TTF_RenderText_Solid(this->NameFont,lcharText,(SDL_Color){1,1,1});
      //this->SetColorFont(intTMPR,intTMPG,intTMPB);

      this->TempRect.x = lintx+2;
      this->TempRect.y = linty+2;
      this->TempRect.w = LimageShadow->w;
      this->TempRect.h = LimageShadow->h;
   
      if(this->RotateText!=0)
      {
         LimageR = rotozoomSurface(LimageShadow, this->RotateText, 1,SMOOTHING_ON);
         this->TempRect.w = LimageR->h;
         this->TempRect.h = LimageR->w;

         SDL_BlitSurface(LimageR,NULL,this->text_surface,&TempRect);
      }
      else
      {
         SDL_BlitSurface(LimageShadow,NULL,this->text_surface,&TempRect);
      }

      SDL_FreeSurface(LimageShadow);
   }

         
   Limage = TTF_RenderText_Solid(this->NameFont,lcharText, this->colorFont);
   TTF_CloseFont( this->NameFont );
   TTF_Quit();
   
   this->xText   = lintx;
   this->yText   = linty;

   this->TempRect.x =this->xText;
   this->TempRect.y =this->yText;
   this->TempRect.w = Limage->w;
   this->TempRect.h = Limage->h;

   if(this->RotateText!=0)
   {
      LimageR = rotozoomSurface(Limage, this->RotateText, 1,SMOOTHING_ON);
      this->TempRect.w = LimageR->h;
      this->TempRect.h = LimageR->w;

      SDL_BlitSurface(LimageR,NULL,this->text_surface,&TempRect);
      SDL_FreeSurface(LimageR);
   }
   else
   {
      SDL_BlitSurface(Limage,NULL,this->text_surface,&TempRect);
   }

   SDL_UpdateRect(this->text_surface, 0, 0, 0, 0);
   SDL_FreeSurface(Limage);
   this->UseText = true;
}
//****************************************************************************
// TYPE........: Method
// NAME........: WriteText
// SUMMARY.....: Write text over video
// CREATED.....: 15-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: none
// COMMENT.....: none
//****************************************************************************
void CAPTURE::WriteText(int lintx, int linty, char *lcharText) 
{ 
   this->UseText = false;

   if (this->debug) 
   {
      printf(" > WriteText(%d,%d,%s)\n",lintx, linty, lcharText);
   }
   TTF_Init();

   SDL_Surface *Limage;
   SDL_Surface *LimageR;

   this->NameFont= TTF_OpenFont( this->fontName, this->size_font );
   TTF_SetFontStyle(this->NameFont, TTF_STYLE_NORMAL);
   Limage = TTF_RenderText_Solid(this->NameFont,lcharText, this->colorFont);
   TTF_CloseFont( this->NameFont );
   TTF_Quit();
   
   this->xText   = lintx;
   this->yText   = linty;

   this->TempRect.x =this->xText;
   this->TempRect.y =this->yText;
   this->TempRect.w = Limage->w;
   this->TempRect.h = Limage->h;
   
   if(this->RotateText!=0)
   {
      LimageR = rotozoomSurface(Limage, this->RotateText, 1,SMOOTHING_ON);

      this->TempRect.w = LimageR->h;
      this->TempRect.h = LimageR->w;

      SDL_BlitSurface(LimageR,NULL,this->text_surface,&TempRect);
      SDL_FreeSurface(LimageR);

   }
   else
   {
      SDL_BlitSurface(Limage,NULL,this->text_surface,&TempRect);
   }

   SDL_UpdateRect(this->text_surface, 0, 0, 0, 0);
   SDL_FreeSurface(Limage);

   this->UseText = true;
}

//****************************************************************************
// TYPE........: Method
// NAME........: Circle
// SUMMARY.....: Draw primitive circle over video
// CREATED.....: 30-Oct-2006
// MODIFIED....: 30-Oct-2006
// PARAMETERS..: Int x,y for coodinate, rad for radius and r,g,b for color
// COMMENT.....: none
//****************************************************************************
void CAPTURE::Circle(int lintx, int linty,int lintrad,  int lintR, int lintG,int lintB, TypeSurface lsurfaceScreen )
{
   switch(lsurfaceScreen)
   {
   case TEXTS:
      {
         this->UseText = false;
         circleRGBA(this->text_surface,lintx, linty, lintrad, lintR, lintG, lintB, 255);
         this->UseText = true;
         break;
      }
   case DRAW:
      {
         this->UseDraw = false;
         circleRGBA(this->draw_surface,lintx, linty, lintrad, lintR, lintG, lintB, 255);
         this->UseDraw = true;
         break;
      }
   case ZOOM:
      {
         this->UseZoomOut = false;
         circleRGBA(this->zoomout_surface,lintx, linty, lintrad, lintR, lintG, lintB, 255);
         this->UseZoomOut = true;
         break;
      }
   case VIDEO:
      {
         this->UseVideo = false;
         circleRGBA(this->video_surface,lintx, linty, lintrad, lintR, lintG, lintB, 255);
         this->UseVideo = true;
         break;
      }

   }
}


//****************************************************************************
// TYPE........: Method
// NAME........: Line
// SUMMARY.....: Draw primitive line over video
// CREATED.....: 19-June2005
// MODIFIED....: 01-July-2005
// PARAMETERS..: Int x1,x2 to x2,y2 and r,g,G
// COMMENT.....: none
//****************************************************************************
void CAPTURE::Line(int lintx1, int linty1,int lintx2, int linty2,  int lintR, int lintG,int lintB, TypeSurface lsurfaceScreen)
{
   switch(lsurfaceScreen)
   {
   case TEXTS:
      {
         this->UseText = false;
         lineRGBA(this->text_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseText = true;
         break;
      }
   case DRAW:
      {
         this->UseDraw = false;
         lineRGBA(this->draw_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseDraw = true;
         break;
      }
   case ZOOM:
      {
         this->UseZoomOut = false;
         lineRGBA(this->zoomout_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseZoomOut = true;
         break;
      }
   case VIDEO:
      {
         this->UseVideo = false;
         lineRGBA(this->video_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseVideo = true;
         break;
      }

   } 
}
//****************************************************************************
// TYPE........: Method
// NAME........: Rectangle
// SUMMARY.....: Draw rectangle over surface zoomout
// CREATED.....: 15-Nov-2005
// MODIFIED....: 01-Nov-2005
// PARAMETERS..: Int x1,x2 to x2,y2 and r,g,G
// COMMENT.....: none
//****************************************************************************
void CAPTURE::RectangleZoom(int lintx1, int linty1,int lintx2, int linty2,  int lintR, int lintG,int lintB )
{
   //this->UseZoomOut  = false;
   rectangleRGBA(this->zoomout_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
   //this->UseZoomOut  = true;

}

//****************************************************************************
// TYPE........: Method
// NAME........: Rectangle
// SUMMARY.....: Draw rectangle over video
// CREATED.....: 15-Nov-2005
// MODIFIED....: 01-Nov-2005
// PARAMETERS..: Int x1,x2 to x2,y2 and r,g,G
// COMMENT.....: none
//****************************************************************************
void CAPTURE::Rectangle(int lintx1, int linty1,int lintx2, int linty2,  int lintR, int lintG,int lintB, TypeSurface lsurfaceScreen)
{
   switch(lsurfaceScreen)
   {
   case TEXTS:
      {
         this->UseText = false;
         rectangleRGBA(this->text_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseText = true;
         break;
      }
   case DRAW:
      {
         this->UseDraw = false;
         rectangleRGBA(this->draw_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseDraw = true;
         break;
      }
   case ZOOM:
      {
         this->UseZoomOut = false;
         rectangleRGBA(this->zoomout_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseZoomOut = true;
         break;
      }
   case VIDEO:
      {
         this->UseVideo = false;
         rectangleRGBA(this->video_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseVideo = true;
         break;
      }

   }

}

//****************************************************************************
// TYPE........: Method
// NAME........: Rectangle
// SUMMARY.....: Draw rectangle fill over video
// CREATED.....: 15-Oct-2005
// MODIFIED....: 20-Mar-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::RectangleFill(int lintx1, int linty1,int lintx2, int linty2,  int lintR, int lintG,int lintB, TypeSurface lsurfaceScreen)
{
   switch(lsurfaceScreen)
   {
   case TEXTS:
      {
         this->UseText = false;
         boxRGBA(this->text_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseText = true;
         break;
      }
   case DRAW:
      {
         this->UseDraw = false;
         boxRGBA(this->draw_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseDraw = true;
         break;
      }
   case ZOOM:
      {
         this->UseZoomOut = false;
         boxRGBA(this->zoomout_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseZoomOut = true;
         break;
      }
   case VIDEO:
      {
         this->UseVideo = false;
         boxRGBA(this->video_surface,lintx1, linty1,lintx2,  linty2,  lintR, lintG, lintB, 255);
         this->UseVideo = true;
         break;
      }
   }
}

//****************************************************************************
// TYPE........: Method
// NAME........: Rectangle
// SUMMARY.....: Draw a bar progress                 
// CREATED.....: 15-Nov-2005
// MODIFIED....: 17-Nov-2005
//****************************************************************************
void CAPTURE::Progress(char *lcharText,int lintPROGRESS, int lintTOTAL)
{
   int intTMPR, intTMPG, intTMPB;

   intTMPR = this->colorFont.r;
   intTMPG = this->colorFont.g;
   intTMPB = this->colorFont.b;
   this->SetColorFont(this->colorFontVideo.r,this->colorFontVideo.g,this->colorFontVideo.b);

   ClearSurface(TEXTS,this->left,this->top,this->width,this->height);


   if(this->RotateText!=0)
   {
     int lintY1 = this->top+10;
     int lintY2 = this->top+((lintPROGRESS*int(this->height -10))/lintTOTAL);
      WriteText(this->left+10,lintY1, lcharText, 30, true);
      this->UseText = false;
      boxRGBA(this->text_surface,this->left+43,lintY1-2,this->left+77,lintY2+2,0,0,0,255);
      boxRGBA(this->text_surface,this->left+45,lintY1,this->left+75,lintY2,255,255,255,255);
      this->UseText = true;
   }
   else
   {
      int lintX1 = this->left+10;
      int lintX2 = this->left+((lintPROGRESS*int(this->width -10))/lintTOTAL);
      WriteText(lintX1,this->top+10, lcharText, 30, true);
   
      this->UseText = false;
      boxRGBA(this->text_surface,lintX1-2,this->top+43,lintX2+2,this->top+77,0,0,0,255);
      boxRGBA(this->text_surface,lintX1,this->top+45,lintX2,this->top+75,255,255,255,255);
      this->UseText = true;
   }

   this->SetColorFont(intTMPR,intTMPG,intTMPB);
   
}

//****************************************************************************
// TYPE........: Method
// NAME........: LoadBMP
// SUMMARY.....: Draw Bitmap image over video
// CREATED.....: 19-June2005
// MODIFIED....: 26-July-2005
// PARAMETERS..: char * lcharBMP
// COMMENT.....: none
//****************************************************************************
void CAPTURE::LoadBMP(char * lcharBMP) 
{
   this->UseDraw = false;
   SDL_Surface *Limage;
   Limage = SDL_LoadBMP(lcharBMP);
   SDL_SetColorKey(Limage,SDL_RLEACCEL,this->colorTransparent);
   SDL_BlitSurface(Limage, NULL, this->draw_surface, NULL);
   SDL_UpdateRect(this->draw_surface, 0, 0, 0, 0);
   SDL_FreeSurface(Limage);
   this->UseDraw = true;
}       

//***************************************************************************
// TYPE........: Method
// NAME........: ZoomOut
// SUMMARY.....: Show static image 
// CREATED.....: 19-June2005
// MODIFIED....: 12-Setp-2005
// PARAMETERS..: bool lboolStatus
// COMMENT.....: none
//****************************************************************************
void CAPTURE::ZoomOut(bool lboolStatus)
{
        
   this->TempRect.x=1;
   this->TempRect.y=1;
   this->TempRect.w=this->width/2;
   this->TempRect.h =this->height/2;
        
   this->UseZoomOut  = false;
   if(lboolStatus)
   {
      SDL_Surface *Limage;
      Limage = zoomSurface(this->offscreen, 0.5,0.5, 1);

      SDL_BlitSurface(Limage, NULL, this->zoomout_surface, NULL);
      SDL_UpdateRect(this->zoomout_surface, 0, 0, 0, 0);
      this->UseZoomOut  = true;
      SDL_FreeSurface(Limage);
   }
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetFormatPalette
// SUMMARY.....: Set video palette 
// CREATED.....: 07-Agu-005
// MODIFIED....: 07-Agu-0050
// PARAMETERS..: int lFormat
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetFormatPalette(int lFormat)
{
   this->lintVideoFormat = lFormat;   
   this->map_buffer.format = lFormat;
   this->pic.palette = lFormat;
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetInputTelevision
// SUMMARY.....: Set mode input television
// CREATED.....: 07-Agu-005
// MODIFIED....: 07-Agu-0050
// PARAMETERS..: int lVideoMode
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetInputTelevision(int lVideoMode)
{
   this->lintVideoMode = lVideoMode;
   vch.channel = 0;
   vch.norm = lVideoMode;
   vch.type = VIDEO_TYPE_TV;
   vch.flags = VIDEO_VC_TUNER |VIDEO_VC_AUDIO;  
   //vtuner.tuner = 77,25;
 
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetInputCamera
// SUMMARY.....: Set mode input Camera
// CREATED.....: 07-Agu-005
// MODIFIED....: 07-Agu-0050
// PARAMETERS..: int lVideoMode
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetInputCamera(int lInput, int lVideoMode)
{
   this->lintVideoMode = lVideoMode;
   vch.channel = lInput;
   vch.norm  = lVideoMode;
   vch.type  = VIDEO_TYPE_CAMERA;
}


//***************************************************************************
// TYPE........: Method
// NAME........: SetTransparent
// SUMMARY.....: Set Transparent color
// CREATED.....: 12-Setp-2005
// MODIFIED....: 12-Setp-2005
// PARAMETERS..: int lintR , int lintG,int lintB
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetTransparent(int lintR, int lintG,int lintB )
{
   this->SRCcolorTransparent.r =lintR;
   this->SRCcolorTransparent.g =lintG;
   this->SRCcolorTransparent.b =lintB;
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetKeyZoomOutOn
// SUMMARY.....: Set key in ZoomOutOn
// CREATED.....: 12-Setp-2005
// MODIFIED....: 12-Setp-2005
// PARAMETERS..: SDLKey Lkey
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetKeyZoomOutOn(SDLKey Lkey)
{
   this->KeyZoomOutOn=Lkey;
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetKeyZoomOutOff
// SUMMARY.....: Set key in ZoomOutOff
// CREATED.....: 12-Setp-2005
// MODIFIED....: 12-Setp-2005
// PARAMETERS..: SDLKey Lkey
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetKeyZoomOutOff(SDLKey Lkey)
{
   this->KeyZoomOutOff=Lkey;
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetKeyFullScreeen
// SUMMARY.....: Set key in FullScreeen
// CREATED.....: 12-Setp-2005
// MODIFIED....: 12-Setp-2005
// PARAMETERS..: SDLKey Lkey
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetKeyFullScreeen(SDLKey Lkey)
{
   this->KeyFullScreeen=Lkey;
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetKeySaveFrame
// SUMMARY.....: Set key in SaveFrame
// CREATED.....: 12-Setp-2005
// MODIFIED....: 12-Setp-2005
// PARAMETERS..: SDLKey Lkey
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetKeySaveFrame(SDLKey Lkey)
{
   this->KeySaveFrame=Lkey;
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetKeySaveFrame
// SUMMARY.....: Set key in SaveFrame
// CREATED.....: 12-Setp-2005
// MODIFIED....: 12-Setp-2005
// PARAMETERS..: SDLKey Lkey
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetKeyQuit(SDLKey Lkey)
{
   this->KeyQuit=Lkey;
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetKeyVideoOn
// SUMMARY.....: Set key for play mpeg video
// CREATED.....: 11-Oct-2005
// MODIFIED....: 11-Oct2005
// PARAMETERS..: SDLKey Lkey
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetKeyVideoOn(SDLKey Lkey)
{
   this->KeyVideoOn=Lkey;
}
//***************************************************************************
// TYPE........: Method
// NAME........: ShowMouse
// SUMMARY.....: Enable mouse cursor
// CREATED.....: 11-Nov-2005
// MODIFIED....: 11-Nov-2005
// COMMENT.....: none
//****************************************************************************
void CAPTURE::ShowMouse(void)
{
   SDL_ShowCursor(SDL_ENABLE);
}

//***************************************************************************
// TYPE........: Method
// NAME........: HideMouse
// SUMMARY.....: Disable mouse cursor
// CREATED.....: 11-Nov-2005
// MODIFIED....: 11-Nov-2005
// COMMENT.....: none
//****************************************************************************
void CAPTURE::HideMouse(void)
{
   SDL_ShowCursor(SDL_DISABLE);
}

//***************************************************************************
// TYPE........: Method
// NAME........: DefinePositionButton 
// SUMMARY.....: Define the position button
// CREATED.....: 11-Nov-2005
// MODIFIED....: 11-Nov-2005
// COMMENT.....: none
//****************************************************************************
void CAPTURE::DefinePositionButton(int lintBUTTON,int lintX, int lintY, int lintW, int lintH)
{
   this->gButtons[lintBUTTON].x = lintX;
   this->gButtons[lintBUTTON].y = lintY;
   this->gButtons[lintBUTTON].w = lintW;
   this->gButtons[lintBUTTON].h = lintH;
}

//***************************************************************************
// TYPE........: Method
// NAME........: FindButton
// SUMMARY.....: Scan a button
// CREATED.....: 11-Nov-2005
// MODIFIED....: 11-Nov-2005
// COMMENT.....: none
//****************************************************************************
int CAPTURE::FindButton(int lintX, int lintY)
{
   int lreturn = -1;
   for (int i=MAX_BUTTON; i>=0; i--)
   {
   if(((lintX>this->gButtons[i].x)  &&
       (lintX<(this->gButtons[i].x+this->gButtons[i].w))) &&
      ((lintY>this->gButtons[i].y)  &&
       (lintY<(this->gButtons[i].y+this->gButtons[i].h))))
       lreturn = i;

   }
   return lreturn;
}

//***************************************************************************
// TYPE........: Method
// NAME........: GetLastKey
// SUMMARY.....: Get Last Button
// CREATED.....: 17-Nov-2005
// MODIFIED....: 17-Nov-2005
// COMMENT.....: none
//****************************************************************************
int CAPTURE::GetLastButton(void)
{
   this->mutex = SDL_CreateMutex();
   this->cond  = SDL_CreateCond();

   SDL_LockMutex(this->mutex);
   SDL_CondWait(this->cond, this->mutex);
   SDL_UnlockMutex(this->mutex);

   return this->LastButton;
}

//***************************************************************************
// TYPE........: Method
// NAME........: TouchScreen 
// SUMMARY.....: On/Off Touch Screen Display
// CREATED.....: 17-Nov-2005
// MODIFIED....: 17-Nov-2005
// COMMENT.....: none
//****************************************************************************
int CAPTURE::TouchScreen(bool lboolSTATUS)
{
   if(!lboolSTATUS)
      this->ScanButtons = false;
   else
   {
      this->LastButton = -1;
      this->ScanButtons = true;
   }

}

//***************************************************************************
// TYPE........: Method
// NAME........: SelectContrast
// SUMMARY.....: Select the function contrast
// CREATED.....: 17-Mar-2006
// MODIFIED....: 17-Mar-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SelectContrast(int lintVALUE)
{
   this->pic.contrast = lintVALUE;
   if(this->pic.contrast>64500)
   this->pic.contrast=64500;

   Progress("Contrast",this->pic.contrast,64500);

   if (-1==ioctl( this->fd, VIDIOCSPICT, &this->pic ))
   printf(" > ERRO: V4L function ioctl VIDIOCSPICT.\n");


}

//***************************************************************************
// TYPE........: Method
// NAME........: SelectBrightness
// SUMMARY.....: Select the function brightness
// CREATED.....: 17-Mar-2006
// MODIFIED....: 17-Mar-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SelectBrightness(int lintVALUE)
{
   this->pic.brightness = lintVALUE;
   if(this->pic.brightness>64500)
   this->pic.brightness=64500;

   Progress("Brightness",this->pic.brightness,64500);

   if (-1==ioctl( this->fd, VIDIOCSPICT, &this->pic ))
   printf(" > ERRO: V4L function ioctl VIDIOCSPICT.\n");

}

//***************************************************************************
// TYPE........: Method
// NAME........: SelectColor
// SUMMARY.....: Select the function color
// CREATED.....: 17-Mar-2006
// MODIFIED....: 17-Mar-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SelectColor(int lintVALUE)
{


   this->pic.colour = lintVALUE;
   if(this->pic.colour>64500)
   this->pic.colour=64500;

   Progress("Color",this->pic.colour,64500);

   if (-1==ioctl( this->fd, VIDIOCSPICT, &this->pic ))
   printf(" > ERRO: V4L function ioctl VIDIOCSPICT.\n");
}

//***************************************************************************
// TYPE........: Method
// NAME........: SelectHue
// SUMMARY.....: Select the function hue
// CREATED.....: 17-Mar-2006
// MODIFIED....: 17-Mar-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SelectHue(void)
{
   this->adjustVIDEO = 1;
   Progress("Hue",this->pic.brightness,65535);
}


//***************************************************************************
// TYPE........: Method
// NAME........: Select Adjust Video
// SUMMARY.....: Adjust Video Live
// CREATED.....: 17-Nov-2005
// MODIFIED....: 17-Nov-2005
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SelectAdjust(int lintMOVEMENT)
{
   this->adjustVIDEO += lintMOVEMENT;
   
   if(this->adjustVIDEO>3)
   this->adjustVIDEO = 0;

   if(this->adjustVIDEO<0)
   this->adjustVIDEO = 3;

   switch(this->adjustVIDEO)
   {
   case 0:
      {
         Progress("Brightness",this->pic.brightness,65535);
         break;
      }
   case 1:
      {
         Progress("Hue",this->pic.hue,65500);
         break;
      }
  case 2:
      {
         Progress("Color",this->pic.colour,65535);
         break;
     }
  case 3:
      {
         Progress("Contrast",this->pic.contrast,65535);
         break;
      }

   }
}


//***************************************************************************
// TYPE........: Method
// NAME........: AdjustVideo 
// SUMMARY.....: Adjust Video Live
// CREATED.....: 17-Nov-2005
// MODIFIED....: 17-Nov-2005
// COMMENT.....: none
//****************************************************************************
void CAPTURE::AdjustVideo(int lintMOVEMENT)
{
if(!this->imageAdjust)
{
   this->imageAdjust = true;  
   lintMOVEMENT *= 1000;

   switch(this->adjustVIDEO)
   {
   case 0:
      {
         this->pic.brightness += lintMOVEMENT;
         if(this->pic.brightness>64500)
         this->pic.brightness=64500;

         if(this->pic.brightness<1500)
         this->pic.brightness=1500;
         Progress("Brightness",this->pic.brightness,65535);
         printf("%d\n",this->pic.brightness); 
         break;
      }
   case 1:
      {
         this->pic.hue += lintMOVEMENT;
         if(this->pic.hue>64500)
         this->pic.hue=64500;

         if(this->pic.hue<1500)
         this->pic.hue=1500;
         Progress("Hue",this->pic.hue,65500);
         break;
      }
  case 2:
      {
         this->pic.colour += lintMOVEMENT;
         if(this->pic.colour>64500)
         this->pic.colour=64500;

         if(this->pic.colour<1500)
         this->pic.colour=1500;
         Progress("Color",this->pic.colour,65535);
         break;
      }
  case 3:
      {
         this->pic.contrast += lintMOVEMENT;
         if(this->pic.contrast>64500)
         this->pic.contrast=64500;

         if(this->pic.contrast<1500)
         this->pic.contrast=1500;
         Progress("Contrast",this->pic.contrast,65535);
         break;
      }

   }
   if (-1==ioctl( this->fd, VIDIOCSPICT, &this->pic ))
   {
      printf(" > ERRO: V4L function ioctl VIDIOCSPICT.\n");
         //exit(-1);
   }
   this->imageAdjust = false;
}   
}
//***************************************************************************
// TYPE........: Method
// NAME........: SetColorFont
// SUMMARY.....: Define the color font
// CREATED.....: 18-Nov-2005
// MODIFIED....: 18-Nov-2005
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetColorFont( int lintR, int lintG,int lintB )
{
   this->colorFont.r    = lintR;
   this->colorFont.g    = lintG;
   this->colorFont.b    = lintB;

}


//***************************************************************************
// TYPE........: Method
// NAME........: GetTouch
// SUMMARY.....: Input Touch Screen
// CREATED.....: 24-Jan-2006
// MODIFIED....: 24-Jan-2006
// COMMENT.....: none
//****************************************************************************
std::string CAPTURE::GetTouch(int lintX, int lintY,int linSize_font, bool lboolShadow)
{
   std::string gstringTXT ="";
   std::string lstringBUFFER ="";

   while(this->LastButton != 11)
   {  ToString(this->GetLastButton());
      if(this->LastButton == 10)
      {
         lstringBUFFER = "";
         this->ClearSurface(TEXTS);
      }
      else
      {
         if((this->LastButton != 11) && (this->LastButton != -1))
         { 
            lstringBUFFER += ToString(this->LastButton);

            if((lstringBUFFER.size()==1) && (gstringTXT.empty()))
            this->ClearSurface(TEXTS);

//            gstringTXT = ": "+lstringBUFFER;
             gstringTXT = lstringBUFFER;
            this->WriteText(lintX,lintY,(char *)gstringTXT.c_str(),linSize_font,lboolShadow);
         }
         usleep(1); 
      }

      if(gstringTXT.size() > (this->MaxTextTouch))
      {
         lstringBUFFER = "";
         this->ClearSurface(TEXTS);
      }    
      
   }
   this->LastButton = -1;

   printf(" > Result of GetTouch: %s\n", lstringBUFFER.c_str());

   return lstringBUFFER;

}
//***************************************************************************
// TYPE........: Method
// NAME........: SetImageFile
// SUMMARY.....: Define type and image file.
// CREATED.....: 09-Jan-2006
// MODIFIED....: 09-Jan-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetImageFile(char *lcharImageFile, TypeImage ltypeimageType)
{
   this->imageFile = lcharImageFile;
   this->typeImageFile = ltypeimageType;
}
//***************************************************************************
// TYPE........: Method
// NAME........: VideoCapture
// SUMMARY.....: Save frame in the disk.
// CREATED.....: 09-Jan-2006
// MODIFIED....: 09-Jan-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::VideoCapture(void)
{
   switch(this->typeImageFile)
   {
   case PPM:
      {
         this->SavePPM((char*)this->imageFile.c_str());
      }
   case JPG:
      {
         this->SaveJPG((char*)this->imageFile.c_str());
      }
   }
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetHardwareWebCam 
// SUMMARY.....: Set the property for operation in webcam.
// CREATED.....: 24-Ago-2006
// MODIFIED....: 24-Ago-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetHardwareWebCam(void)
{

   this->map_buffer.format = VIDEO_PALETTE_YUV420P;
   this->lintVideoFormat   = VIDEO_PALETTE_YUV420P;
   this->pic.palette       = VIDEO_PALETTE_YUV420P;

}

//***************************************************************************
// TYPE........: Method
// NAME........: SetHardwareCaptureCard
// SUMMARY.....: Set the property for operation in capture card.
// CREATED.....: 24-Ago-2006
// MODIFIED....: 24-Ago-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetHardwareCaptureCard(void)
{

   this->map_buffer.format = VIDEO_PALETTE_RGB24;
   this->lintVideoFormat   = VIDEO_PALETTE_RGB24;
   this->pic.palette       = VIDEO_PALETTE_RGB24;

}

//***************************************************************************
// TYPE........: Method
// NAME........: SetInputChannel
// SUMMARY.....: Set input channel in Television
// CREATED.....: 26-Ago-2006
// MODIFIED....: 26-Ago-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetInputChannel(int lintVALUE)
{

   this->vch.channel = lintVALUE;

   if (-1==ioctl( this->fd, VIDIOCGCHAN, &this->vch ))
   printf(" > ERRO: V4L function ioctl VDIOCGCHAN.\n");

   if (-1==ioctl( this->fd, VIDIOCSCHAN, &this->vch ))
   printf(" > ERRO: V4L function ioctl VIDIOCSCHAN.\n");

}

//***************************************************************************
// TYPE........: Method
// NAME........: MaxWidth
// SUMMARY.....: Return the Max witdth of the main window
// CREATED.....: 05-Sep-2006
// MODIFIED....: 05-Sep-2006
// COMMENT.....: none
//****************************************************************************
int CAPTURE::MaxWidth(void)
{
   return this->widthWin;
}

//***************************************************************************
// TYPE........: Method
// NAME........: MaxHeight
// SUMMARY.....: Return the Max height of the main window
// CREATED.....: 05-Sep-2006
// MODIFIED....: 05-Sep-2006
// COMMENT.....: none
//****************************************************************************
int CAPTURE::MaxHeight(void)
{
   return this->heightWin;
}

//***************************************************************************
// TYPE........: Method
// NAME........: SetMaxTextTouch
// SUMMARY.....: Set the max lenght for input touchscreen
// CREATED.....: 05-Sep-2006
// MODIFIED....: 05-Sep-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::SetMaxTextTouch(int lintVALUE)
{
   this->MaxTextTouch = lintVALUE;
}

//***************************************************************************
// TYPE........: Method
// NAME........: FullScreen
// SUMMARY.....: Enable/Disable full Screen mode.
// CREATED.....: 21-Oct-2006
// MODIFIED....: 21-Oct-2006
// COMMENT.....: none
//****************************************************************************
void CAPTURE::FullScreen(void)
{
   SDL_WM_ToggleFullScreen(this->screen);
}

}

---