/*
 *  VBI proxy test client
 *
 *  Copyright (C) 2003, 2004 Tom Zoerner
 *
 *  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., 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301, USA.
 *
 *
 *  Description:
 *
 *    This is a small demo application for the VBI proxy and libzvbi.
 *    It will read VBI data from the device given on the command line
 *    and dump requested services' data to standard output.  See below
 *    for a list of possible options.
 *
 *  $Log: not supported by cvs2svn $
 *  Revision 1.20  2008/03/01 07:36:32  mschimek
 *  Line feed cosmetics.
 *
 *  Revision 1.19  2007/11/27 18:26:48  mschimek
 *  Updated the FSF address in the copyright notice.
 *
 *  Revision 1.18  2007/11/03 21:15:38  tomzo
 *  Bugfix setup of raw capture handling
 *
 *  Revision 1.17  2006/02/10 06:25:38  mschimek
 *  *** empty log message ***
 *
 *  Revision 1.16  2004/12/31 06:05:20  mschimek
 *  *** empty log message ***
 *
 *  Revision 1.15  2004/11/07 10:52:47  mschimek
 *  *** empty log message ***
 *
 *  Revision 1.4  2004/11/07 08:18:53  michael
 *  *** empty log message ***
 *
 *  Revision 1.14  2004/11/03 17:07:40  mschimek
 *  *** empty log message ***
 *
 *  Revision 1.3  2004/10/29 01:49:04  michael
 *  *** empty log message ***
 *
 *  Revision 1.13  2004/10/25 16:56:30  mschimek
 *  *** empty log message ***
 *
 *  Revision 1.12  2004/10/24 18:20:00  tomzo
 *  Added test support for norm change handling
 *
 *  Revision 1.7  2003/06/07 09:43:23  tomzo
 *  Added test for proxy with select() and zero timeout (#if 0'ed)
 *
 *  Revision 1.6  2003/06/01 19:36:42  tomzo
 *  Added tests for TV channel switching
 *  - added new command line options -channel, -freq, -chnprio
 *  - use new func vbi_capture_channel_change()
 *
 *  Revision 1.5  2003/05/24 12:19:57  tomzo
 *  - added dynamic service switch to test add_service() interface: new function
 *    read_service_string() reads service requests from stdin
 *  - added new service closed caption
 *
 *  Revision 1.4  2003/05/10 13:31:23  tomzo
 *  - bugfix main loop: check for 0 result from vbi_capture_pull_sliced()
 *    and for NULL pointer for sliced buffer
 *  - added new "-debug 0..2" option: old "-trace" could only set level 1
 *  - split off argv parsing from main function
 *
 *  Revision 1.3  2003/05/03 12:07:48  tomzo
 *  - use vbi_capture_pull_sliced() instead of vbi_capture_read_sliced()
 *  - fixed copyright headers, added description to file headers
 *
 */

static const char
rcsid [] = "$Id: proxy-test.c,v 1.21 2008-07-26 06:22:19 mschimek Exp $";

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <inttypes.h>

#define USE_LIBZVBI
#include "src/libzvbi.h"

#ifdef ENABLE_V4L
#include "src/videodev.h"
#endif


#define DEVICE_PATH   "/dev/vbi0"
#define BUFFER_COUNT  5

typedef enum
{
   TEST_API_V4L,
   TEST_API_V4L2,
   TEST_API_PROXY,
} PROXY_TEST_API;

typedef enum
{
   TEST_SCANNING_BOTH  = 0,
   TEST_SCANNING_625   = 625,
   TEST_SCANNING_525   = 525,
} PROXY_TEST_SCANNING;

static char         * p_dev_name = DEVICE_PATH;
static PROXY_TEST_API opt_api = TEST_API_PROXY;
static PROXY_TEST_SCANNING opt_scanning = TEST_SCANNING_BOTH;
static unsigned int   opt_services;
static int            opt_strict;
static int            opt_debug_level;
static int            opt_channel;
static int            opt_frequency;
static int            opt_chnprio;
static int            opt_subprio;

static int            update_services;


#define ALL_SERVICES_625 ( VBI_SLICED_TELETEXT_B | \
                           VBI_SLICED_VPS | \
                           VBI_SLICED_CAPTION_625 | \
                           VBI_SLICED_WSS_625 | \
                           VBI_SLICED_VBI_625 )
#define ALL_SERVICES_525 ( VBI_SLICED_CAPTION_525 | \
                           VBI_SLICED_2xCAPTION_525 | \
                           VBI_SLICED_TELETEXT_BD_525 | \
                           VBI_SLICED_VBI_525 )

/* ---------------------------------------------------------------------------
** Switch channel and frequency (Video 4 Linux #1 API)
*/
static vbi_bool SwitchTvChannel( vbi_proxy_client * vpc, int channel, int freq )
{
#ifdef ENABLE_V4L
   struct video_channel vchan;
   long lfreq;
   vbi_bool result;

   result = TRUE;

   // get current config of the selected chanel
   if (channel != -1)
   {
      result = FALSE;

      memset(&vchan, 0, sizeof(vchan));
      vchan.channel = channel;
      if (opt_scanning == TEST_SCANNING_625)
         vchan.norm = VIDEO_MODE_PAL;
      else if (opt_scanning == TEST_SCANNING_525)
         vchan.norm = VIDEO_MODE_NTSC;

      if (vbi_proxy_client_device_ioctl(vpc, VIDIOCGCHAN, &vchan) == 0)
      {
         vchan.channel = channel;

         if (vbi_proxy_client_device_ioctl(vpc, VIDIOCSCHAN, &vchan) == 0)
         {
            result = TRUE;
         }
         else
            perror("ioctl VIDIOCSCHAN");
      }
      else
         perror("ioctl VIDIOCGCHAN");
   }

   if (freq != -1)
   {
      result = FALSE;

      if ( (channel == -1) ||
           ((vchan.type & VIDEO_TYPE_TV) && (vchan.flags & VIDEO_VC_TUNER)) )
      {
         lfreq = freq;
         if (vbi_proxy_client_device_ioctl(vpc, VIDIOCSFREQ, &lfreq) == 0)
         {
            result = TRUE;
         }
         else
            perror("ioctl VIDIOCSFREQ");
      }
      else
         fprintf(stderr, "cannot tune frequency: channel has no tuner\n");
   }
   return result;
#else
   return FALSE;
#endif
}

/* ----------------------------------------------------------------------------
** Callback for proxy events
*/
static void ProxyEventCallback( void * p_client_data, VBI_PROXY_EV_TYPE ev_mask )
{
   vbi_proxy_client * pProxyClient;
   VBI_PROXY_CHN_FLAGS  flags;

   if (p_client_data != NULL)
   {
      pProxyClient = *(vbi_proxy_client **) p_client_data;
      if (pProxyClient != NULL)
      {
         if (ev_mask & VBI_PROXY_EV_CHN_RECLAIMED)
         {
            fprintf(stderr, "ProxyEventCallback: token was reclaimed\n");

            vbi_proxy_client_channel_notify(pProxyClient, VBI_PROXY_CHN_TOKEN, 0);
         }
         else if (ev_mask & VBI_PROXY_EV_CHN_GRANTED)
         {
            fprintf(stderr, "ProxyEventCallback: token granted\n");

            if ((opt_channel != -1) || (opt_frequency != -1))
            {
               if (SwitchTvChannel(pProxyClient, opt_channel, opt_frequency))
                  flags = VBI_PROXY_CHN_TOKEN | VBI_PROXY_CHN_FLUSH;
               else
                  flags = VBI_PROXY_CHN_RELEASE | VBI_PROXY_CHN_FAIL | VBI_PROXY_CHN_FLUSH;

               if (opt_scanning != TEST_SCANNING_BOTH)
                  flags |= VBI_PROXY_CHN_NORM;
            }
            else
               flags = VBI_PROXY_CHN_RELEASE;

            vbi_proxy_client_channel_notify(pProxyClient, flags, opt_scanning);
         }
         if (ev_mask & VBI_PROXY_EV_NORM_CHANGED)
         {
            fprintf(stderr, "ProxyEventCallback: TV norm changed\n");
            update_services = TRUE;
         }
      }
   }
}

/* ----------------------------------------------------------------------------
** Resolve parity on an array in-place
** - errors are ignored, the character just replaced by a blank
** - non-printable characters are replaced by blanks
*/
static const signed char parityTab[256] =
{
   //0x80, 0x01, 0x02, 0x83, 0x04, 0x85, 0x86, 0x07,  // non-printable
   //0x08, 0x89, 0x8a, 0x0b, 0x8c, 0x0d, 0x0e, 0x8f,  // non-printable
   //0x10, 0x91, 0x92, 0x13, 0x94, 0x15, 0x16, 0x97,  // non-printable
   //0x98, 0x19, 0x1a, 0x9b, 0x1c, 0x9d, 0x9e, 0x1f,  // non-printable
   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
   0x20, 0xa1, 0xa2, 0x23, 0xa4, 0x25, 0x26, 0xa7,
   0xa8, 0x29, 0x2a, 0xab, 0x2c, 0xad, 0xae, 0x2f,
   0xb0, 0x31, 0x32, 0xb3, 0x34, 0xb5, 0xb6, 0x37,
   0x38, 0xb9, 0xba, 0x3b, 0xbc, 0x3d, 0x3e, 0xbf,
   0x40, 0xc1, 0xc2, 0x43, 0xc4, 0x45, 0x46, 0xc7,
   0xc8, 0x49, 0x4a, 0xcb, 0x4c, 0xcd, 0xce, 0x4f,
   0xd0, 0x51, 0x52, 0xd3, 0x54, 0xd5, 0xd6, 0x57,
   0x58, 0xd9, 0xda, 0x5b, 0xdc, 0x5d, 0x5e, 0xdf,
   0xe0, 0x61, 0x62, 0xe3, 0x64, 0xe5, 0xe6, 0x67,
   0x68, 0xe9, 0xea, 0x6b, 0xec, 0x6d, 0x6e, 0xef,
   0x70, 0xf1, 0xf2, 0x73, 0xf4, 0x75, 0x76, 0xf7,
   0xf8, 0x79, 0x7a, 0xfb, 0x7c, 0xfd, 0xfe,       0x20, // 0x7f,

   //0x00, 0x81, 0x82, 0x03, 0x84, 0x05, 0x06, 0x87,  // non-printable
   //0x88, 0x09, 0x0a, 0x8b, 0x0c, 0x8d, 0x8e, 0x0f,  // non-printable
   //0x90, 0x11, 0x12, 0x93, 0x14, 0x95, 0x96, 0x17,  // non-printable
   //0x18, 0x99, 0x9a, 0x1b, 0x9c, 0x1d, 0x1e, 0x9f,  // non-printable
   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

   0xa0, 0x21, 0x22, 0xa3, 0x24, 0xa5, 0xa6, 0x27,
   0x28, 0xa9, 0xaa, 0x2b, 0xac, 0x2d, 0x2e, 0xaf,
   0x30, 0xb1, 0xb2, 0x33, 0xb4, 0x35, 0x36, 0xb7,
   0xb8, 0x39, 0x3a, 0xbb, 0x3c, 0xbd, 0xbe, 0x3f,
   0xc0, 0x41, 0x42, 0xc3, 0x44, 0xc5, 0xc6, 0x47,
   0x48, 0xc9, 0xca, 0x4b, 0xcc, 0x4d, 0x4e, 0xcf,
   0x50, 0xd1, 0xd2, 0x53, 0xd4, 0x55, 0x56, 0xd7,
   0xd8, 0x59, 0x5a, 0xdb, 0x5c, 0xdd, 0xde, 0x5f,
   0x60, 0xe1, 0xe2, 0x63, 0xe4, 0x65, 0x66, 0xe7,
   0xe8, 0x69, 0x6a, 0xeb, 0x6c, 0xed, 0xee, 0x6f,
   0xf0, 0x71, 0x72, 0xf3, 0x74, 0xf5, 0xf6, 0x77,
   0x78, 0xf9, 0xfa, 0x7b, 0xfc, 0x7d, 0x7e, 0xff,
};
static int UnHamParityArray( const unsigned char *pin, char *pout, int byteCount )
{
   int errCount;
   signed char c1;

   errCount = 0;
   for (; byteCount > 0; byteCount--)
   {
      c1 = (char)parityTab[*(pin++)];
      if (c1 > 0)
      {
         *(pout++) = c1;
      }
      else
      {
         *(pout++) = 0xA0;  /* Latin-1 space character */
         errCount += 1;
      }
   }

   return errCount;
}

static const unsigned char unhamTab[256] =
{
   0x01, 0xff, 0x01, 0x01, 0xff, 0x00, 0x01, 0xff,
   0xff, 0x02, 0x01, 0xff, 0x0a, 0xff, 0xff, 0x07,
   0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0x00,
   0x06, 0xff, 0xff, 0x0b, 0xff, 0x00, 0x03, 0xff,
   0xff, 0x0c, 0x01, 0xff, 0x04, 0xff, 0xff, 0x07,
   0x06, 0xff, 0xff, 0x07, 0xff, 0x07, 0x07, 0x07,
   0x06, 0xff, 0xff, 0x05, 0xff, 0x00, 0x0d, 0xff,
   0x06, 0x06, 0x06, 0xff, 0x06, 0xff, 0xff, 0x07,
   0xff, 0x02, 0x01, 0xff, 0x04, 0xff, 0xff, 0x09,
   0x02, 0x02, 0xff, 0x02, 0xff, 0x02, 0x03, 0xff,
   0x08, 0xff, 0xff, 0x05, 0xff, 0x00, 0x03, 0xff,
   0xff, 0x02, 0x03, 0xff, 0x03, 0xff, 0x03, 0x03,
   0x04, 0xff, 0xff, 0x05, 0x04, 0x04, 0x04, 0xff,
   0xff, 0x02, 0x0f, 0xff, 0x04, 0xff, 0xff, 0x07,
   0xff, 0x05, 0x05, 0x05, 0x04, 0xff, 0xff, 0x05,
   0x06, 0xff, 0xff, 0x05, 0xff, 0x0e, 0x03, 0xff,
   0xff, 0x0c, 0x01, 0xff, 0x0a, 0xff, 0xff, 0x09,
   0x0a, 0xff, 0xff, 0x0b, 0x0a, 0x0a, 0x0a, 0xff,
   0x08, 0xff, 0xff, 0x0b, 0xff, 0x00, 0x0d, 0xff,
   0xff, 0x0b, 0x0b, 0x0b, 0x0a, 0xff, 0xff, 0x0b,
   0x0c, 0x0c, 0xff, 0x0c, 0xff, 0x0c, 0x0d, 0xff,
   0xff, 0x0c, 0x0f, 0xff, 0x0a, 0xff, 0xff, 0x07,
   0xff, 0x0c, 0x0d, 0xff, 0x0d, 0xff, 0x0d, 0x0d,
   0x06, 0xff, 0xff, 0x0b, 0xff, 0x0e, 0x0d, 0xff,
   0x08, 0xff, 0xff, 0x09, 0xff, 0x09, 0x09, 0x09,
   0xff, 0x02, 0x0f, 0xff, 0x0a, 0xff, 0xff, 0x09,
   0x08, 0x08, 0x08, 0xff, 0x08, 0xff, 0xff, 0x09,
   0x08, 0xff, 0xff, 0x0b, 0xff, 0x0e, 0x03, 0xff,
   0xff, 0x0c, 0x0f, 0xff, 0x04, 0xff, 0xff, 0x09,
   0x0f, 0xff, 0x0f, 0x0f, 0xff, 0x0e, 0x0f, 0xff,
   0x08, 0xff, 0xff, 0x05, 0xff, 0x0e, 0x0d, 0xff,
   0xff, 0x0e, 0x0f, 0xff, 0x0e, 0x0e, 0xff, 0x0e
};
#define UnHam84Byte(P,V)   (( *(V) = ((int)unhamTab[*((const unsigned char *)(P))] | ((int)unhamTab[*(((const unsigned char *)(P))+1)] << 4)) ) >= 0 )

/* ---------------------------------------------------------------------------
** Decode a teletext data line
*/
static void PrintTeletextData( const unsigned char * data, int line, int id )
{
   char  tmparr[46];
   int   tmp1, tmp2, tmp3;
   uint  mag, pkgno, pageNo, sub;

   mag    =    0xF;
   pkgno  =   0xFF;
   pageNo =  0xFFF;
   sub    = 0xFFFF;
   if (UnHam84Byte(data, &tmp1))
   {
      pkgno = (tmp1 >> 3) & 0x1f;
      mag   = tmp1 & 7;
      if (mag == 0)
         mag = 8;
      if (UnHam84Byte(data + 2, &tmp1) &&
          UnHam84Byte(data + 4, &tmp2) &&
          UnHam84Byte(data + 6, &tmp3))
      {  /* it's a page header: decode page number and sub-page code */
         pageNo = tmp1 | ((uint)mag << 8);
         sub    = (tmp2 | (tmp3 << 8)) & 0x3f7f;
      }
   }

   if (pkgno != 0)
   {
      UnHamParityArray(data+2, tmparr, 40);
      tmparr[40] = 0;
      printf("line %3d id=%d pkg %X.%03X: '%s'\n", line, id, mag, pkgno, tmparr);
   }
   else
   {
      UnHamParityArray(data+2+8, tmparr, 40-8);
      tmparr[40-8] = 0;
      printf("line %3d id=%d page %03X.%04X: '%s'\n", line, id, pageNo, sub, tmparr);
   }
}

/* ---------------------------------------------------------------------------
** Decode a VPS data line
** - bit fields are defined in "VPS Richtlinie 8R2" from August 1995
** - called by the VBI decoder for every received VPS line
*/
static void PrintVpsData( const unsigned char * data )
{
   uint mday, month, hour, minute;
   uint cni;

#define VPSOFF -3

   cni = ((data[VPSOFF+13] & 0x3) << 10) | ((data[VPSOFF+14] & 0xc0) << 2) |
         ((data[VPSOFF+11] & 0xc0)) | (data[VPSOFF+14] & 0x3f);

   if ((cni != 0) && (cni != 0xfff))
   {
      if (cni == 0xDC3)
      {  /* special case: "ARD/ZDF Gemeinsames Vormittagsprogramm" */
         cni = (data[VPSOFF+5] & 0x20) ? 0xDC1 : 0xDC2;
      }

      /* decode VPS PIL */
      mday   =  (data[VPSOFF+11] & 0x3e) >> 1;
      month  = ((data[VPSOFF+12] & 0xe0) >> 5) | ((data[VPSOFF+11] & 1) << 3);
      hour   =  (data[VPSOFF+12] & 0x1f);
      minute =  (data[VPSOFF+13] >> 2);

      printf("VPS %d.%d. %02d:%02d CNI 0x%04X\n", mday, month, hour, minute, cni);
   }
}

/* ---------------------------------------------------------------------------
** Check stdin for services change requests
** - syntax: ["+"|"-"|"="]keyword, e.g. "+vps-ttx" or "=wss"
*/
static unsigned int read_service_string( void )
{
   unsigned int    services;
   unsigned int    tmp_services;
   struct timeval  timeout;
   vbi_bool substract;
   fd_set   rd;
   char  buf[100];
   char  *p_inp;
   int   ret;

   services = opt_services;
   timeout.tv_sec  = 0;
   timeout.tv_usec = 0;
   FD_ZERO(&rd);
   FD_SET(0, &rd);

   ret = select(1, &rd, NULL, NULL, &timeout);
   if (ret == 1)
   {
      ret = read(0, buf, sizeof(buf));
      if (ret > 0)
      {
         p_inp = buf;
         while (*p_inp != 0)
         {
            while (*p_inp == ' ')
               p_inp += 1;

            substract = FALSE;
            if (*p_inp == '=')
            {
               services = 0;
               p_inp += 1;
            }
            else if (*p_inp == '-')
            {
               substract = TRUE;
               p_inp += 1;
            }
            else if (*p_inp == '+')
               p_inp += 1;

            if ( (strncasecmp(p_inp, "ttx", 3) == 0) ||
                 (strncasecmp(p_inp, "teletext", 8) == 0) )
            {
               tmp_services = VBI_SLICED_TELETEXT_B | VBI_SLICED_TELETEXT_BD_525;
            }
            else if (strncasecmp(p_inp, "vps", 3) == 0)
            {
               tmp_services = VBI_SLICED_VPS;
            }
            else if (strncasecmp(p_inp, "wss", 3) == 0)
            {
               tmp_services = VBI_SLICED_WSS_625 | VBI_SLICED_WSS_CPR1204;
            }
            else if ( (strncasecmp(p_inp, "cc", 2) == 0) ||
                      (strncasecmp(p_inp, "caption", 7) == 0) )
            {
               tmp_services = VBI_SLICED_CAPTION_625 | VBI_SLICED_CAPTION_525;
            }
            else if (strncasecmp(p_inp, "raw", 3) == 0)
            {
               tmp_services = VBI_SLICED_VBI_625 | VBI_SLICED_VBI_525;
            }
            else
               tmp_services = 0;

            if (substract == FALSE)
               services |= tmp_services;
            else
               services &= ~ tmp_services;

            while ((*p_inp != 0) && (*p_inp != '+') && (*p_inp != '-'))
               p_inp += 1;
         }
      }
      else if ((ret < 0) && (errno != EINTR) && (errno != EAGAIN))
      {
         fprintf(stderr, "read_service_string: read: %d (%s)\n", errno, strerror(errno));
      }
   }
   else if ((ret < 0) && (errno != EINTR) && (errno != EAGAIN))
   {
      fprintf(stderr, "read_service_string: select: %d (%s)\n", errno, strerror(errno));
   }
   return services;
}

/* ---------------------------------------------------------------------------
** Print usage and exit
*/
static void usage_exit( const char *argv0, const char *argvn, const char * reason )
{
   fprintf(stderr, "%s: %s: %s\n"
                   "Usage: %s [ Options ] service ...\n"
                   "Supported services         : ttx | vps | wss | cc | raw\n"
                   "Supported options:\n"
                   "       -dev <path>         : device path\n"
                   "       -api <type>         : v4l API: proxy|v4l2|v4l\n"
                   "       -strict <level>     : service strictness level: 0..2\n"
                   "       -channel <index>    : switch video input channel\n"
                   "       -freq <kHz * 16>    : switch TV tuner frequency\n"
                   "       -chnprio <1..3>     : channel switch priority\n"
                   "       -subprio <0..4>     : background scheduling priority\n"
                   "       -debug <level>      : enable debug output: 1=warnings, 2=all\n"
                   "       -help               : this message\n"
                   "You can also type service requests to stdin at runtime:\n"
                   "Format: [\"+\"|\"-\"|\"=\"]<service>, e.g. \"+vps -ttx\" or \"=wss\"\n",
                   argv0, reason, argvn, argv0);

   exit(1);
}

/* ---------------------------------------------------------------------------
** Parse numeric value in command line options
*/
static vbi_bool parse_argv_numeric( char * p_number, int * p_value )
{
   char * p_num_end;

   if (*p_number != 0)
   {
      *p_value = strtol(p_number, &p_num_end, 0);

      return (*p_num_end == 0);
   }
   else
      return FALSE;
}

/* ---------------------------------------------------------------------------
** Parse command line options
*/
static void parse_argv( int argc, char * argv[] )
{
   int arg_val;
   int arg_idx = 1;
   int have_service = 0;

   opt_debug_level = 0;
   opt_services = 0;
   opt_strict = 0;
   opt_channel = -1;
   opt_frequency = -1;
   opt_chnprio = VBI_CHN_PRIO_INTERACTIVE;
   opt_subprio = 0;

   while (arg_idx < argc)
   {
      if ( (strcasecmp(argv[arg_idx], "ttx") == 0) ||
           (strcasecmp(argv[arg_idx], "teletext") == 0) )
      {
         opt_services |= VBI_SLICED_TELETEXT_B | VBI_SLICED_TELETEXT_BD_525;
         have_service = 1;
         arg_idx += 1;
      }
      else if (strcasecmp(argv[arg_idx], "vps") == 0)
      {
         opt_services |= VBI_SLICED_VPS;
         have_service = 1;
         arg_idx += 1;
      }
      else if (strcasecmp(argv[arg_idx], "wss") == 0)
      {
         opt_services |= VBI_SLICED_WSS_625 | VBI_SLICED_WSS_CPR1204;
         have_service = 1;
         arg_idx += 1;
      }
      else if ( (strcasecmp(argv[arg_idx], "cc") == 0) ||
                (strcasecmp(argv[arg_idx], "caption") == 0) )
      {
         opt_services |= VBI_SLICED_CAPTION_625 | VBI_SLICED_CAPTION_525;
         have_service = 1;
         arg_idx += 1;
      }
      else if (strcasecmp(argv[arg_idx], "raw") == 0)
      {
         opt_services |= VBI_SLICED_VBI_625 | VBI_SLICED_VBI_525;
         have_service = 1;
         arg_idx += 1;
      }
      else if (strcasecmp(argv[arg_idx], "null") == 0)
      {
         have_service = 1;
         arg_idx += 1;
      }
      else if (strcasecmp(argv[arg_idx], "-dev") == 0)
      {
         if (arg_idx + 1 < argc)
         {
            p_dev_name = argv[arg_idx + 1];
	    if (access(p_dev_name, R_OK | W_OK) == -1)
               usage_exit(argv[0], argv[arg_idx +1], "failed to access device");
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing mode keyword after");
      }
      else if (strcasecmp(argv[arg_idx], "-api") == 0)
      {
         if (arg_idx + 1 < argc)
         {
            if (strcasecmp(argv[arg_idx + 1], "proxy") == 0)
               opt_api = TEST_API_PROXY;
#ifdef USE_LIBZVBI
            else if ( (strcasecmp(argv[arg_idx + 1], "v4l") == 0) ||
                      (strcasecmp(argv[arg_idx + 1], "v4l1") == 0) )
               opt_api = TEST_API_V4L;
            else if (strcasecmp(argv[arg_idx + 1], "v4l2") == 0)
               opt_api = TEST_API_V4L2;
#endif
            else
               usage_exit(argv[0], argv[arg_idx +1], "unknown API keyword");
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing mode keyword after");
      }
      else if (strcasecmp(argv[arg_idx], "-norm") == 0)
      {
         if (arg_idx + 1 < argc)
         {
            if ( (strcasecmp("PAL", argv[arg_idx + 1]) == 0) ||
                 (strcasecmp("SECAM", argv[arg_idx + 1]) == 0) )
               opt_scanning = TEST_SCANNING_625;
            else if (strcasecmp("NTSC", argv[arg_idx + 1]) == 0)
               opt_scanning = TEST_SCANNING_525;
            else
               usage_exit(argv[0], argv[arg_idx], "missing mode keyword after");
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing mode keyword after");
      }
      else if (strcasecmp(argv[arg_idx], "-trace") == 0)
      {
         opt_debug_level = 1;
         arg_idx += 1;
      }
      else if (strcasecmp(argv[arg_idx], "-debug") == 0)
      {
         if ((arg_idx + 1 < argc) && parse_argv_numeric(argv[arg_idx + 1], &arg_val))
         {
            opt_debug_level = arg_val;
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing debug level after");
      }
      else if (strcasecmp(argv[arg_idx], "-strict") == 0)
      {
         if ((arg_idx + 1 < argc) && parse_argv_numeric(argv[arg_idx + 1], &arg_val))
         {
            opt_strict = arg_val;
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing strict level after");
      }
      else if (strcasecmp(argv[arg_idx], "-channel") == 0)
      {
         if ((arg_idx + 1 < argc) && parse_argv_numeric(argv[arg_idx + 1], &arg_val))
         {
            opt_channel = arg_val;
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing channel index after");
      }
      else if (strcasecmp(argv[arg_idx], "-freq") == 0)
      {
         if ((arg_idx + 1 < argc) && parse_argv_numeric(argv[arg_idx + 1], &arg_val))
         {
            opt_frequency = arg_val;
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing frequency value after");
      }
      else if (strcasecmp(argv[arg_idx], "-chnprio") == 0)
      {
         if ((arg_idx + 1 < argc) && parse_argv_numeric(argv[arg_idx + 1], &arg_val))
         {
            opt_chnprio = arg_val;
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing priority level after");
      }
      else if (strcasecmp(argv[arg_idx], "-subprio") == 0)
      {
         if ((arg_idx + 1 < argc) && parse_argv_numeric(argv[arg_idx + 1], &arg_val))
         {
            opt_subprio = arg_val;
            arg_idx += 2;
         }
         else
            usage_exit(argv[0], argv[arg_idx], "missing priority level after");
      }
      else if (strcasecmp(argv[arg_idx], "-help") == 0)
      {
         usage_exit(argv[0], "", "the following options are available");
      }
      else
         usage_exit(argv[0], argv[arg_idx], "unknown option or argument");
   }

   if (have_service == 0)
   {
      usage_exit(argv[0], "no service given", "Must specify at least one service");
   }

   if (opt_scanning == TEST_SCANNING_625)
      opt_services &= ALL_SERVICES_625;
   else if (opt_scanning == TEST_SCANNING_525)
      opt_services &= ALL_SERVICES_525;
}


/* ----------------------------------------------------------------------------
** Main entry point
*/
int main ( int argc, char ** argv )
{
   vbi_proxy_client   * pProxyClient;
   vbi_capture        * pVbiCapt;
   vbi_sliced         * pVbiData;
   vbi_capture_buffer * pVbiBuf;
   vbi_raw_decoder      raw_dec;
   char               * pErr;
   struct timeval       timeout;
   unsigned int         new_services;
   unsigned int         cur_services;
   unsigned int       * p_services;
   uint    lineCount;
   uint    lastLineCount;
   uint    line;
   int     res;

   parse_argv(argc, argv);

   fcntl(0, F_SETFL, O_NONBLOCK);

   if ((opt_services != 0) && (opt_scanning == 0))
   {
      cur_services = opt_services;
      p_services = &cur_services;
   }
   else
   {
      cur_services = 0;
      p_services = NULL;
   }

   pProxyClient = NULL;
   pVbiCapt = NULL;
#ifdef USE_LIBZVBI
   if (opt_api == TEST_API_V4L2)
      pVbiCapt = vbi_capture_v4l2_new(p_dev_name, BUFFER_COUNT, p_services, opt_strict, &pErr, opt_debug_level);
   if (opt_api == TEST_API_V4L)
      pVbiCapt = vbi_capture_v4l_new(p_dev_name, 0, p_services, opt_strict, &pErr, opt_debug_level);
#endif
   if (opt_api == TEST_API_PROXY)
   {
      pProxyClient = vbi_proxy_client_create(p_dev_name, "proxy-test", 0,
                                             &pErr, opt_debug_level);
      if (pProxyClient != NULL)
      {
         pVbiCapt = vbi_capture_proxy_new(pProxyClient, BUFFER_COUNT, 0, p_services, opt_strict, &pErr );
      }
      vbi_proxy_client_set_callback(pProxyClient, ProxyEventCallback, &pProxyClient);
   }

   if (pVbiCapt != NULL)
   {
      lastLineCount = -1;

      /* switch to the requested channel */
      if ( (opt_channel != -1) || (opt_frequency != -1) ||
           (opt_chnprio != VBI_CHN_PRIO_INTERACTIVE) )
      {
         vbi_channel_profile  chn_profile;

         memset(&chn_profile, 0, sizeof(chn_profile));

         if ( (opt_chnprio == VBI_CHN_PRIO_BACKGROUND) &&
              ((opt_channel != -1) || (opt_frequency != -1)) )
         {
            chn_profile.is_valid      = TRUE;
            chn_profile.sub_prio      = opt_subprio;
            chn_profile.min_duration  = 10;
         }
         vbi_proxy_client_channel_request(pProxyClient, opt_chnprio, &chn_profile);

         if (opt_chnprio != VBI_CHN_PRIO_BACKGROUND) {
            SwitchTvChannel(pProxyClient, opt_channel, opt_frequency);
         }
      }

      if ((opt_services & (VBI_SLICED_VBI_625 | VBI_SLICED_VBI_525)) != 0)
      {
         vbi_raw_decoder * p_dec;

         /* initialize services for raw capture */
         p_dec = vbi_capture_parameters(pVbiCapt);
         if (p_dec != NULL)
         {
            vbi_raw_decoder_init(&raw_dec);

            raw_dec.scanning = p_dec->scanning; 
            raw_dec.sampling_format = p_dec->sampling_format; 
            raw_dec.sampling_rate = p_dec->sampling_rate; 
            raw_dec.bytes_per_line = p_dec->bytes_per_line; 
            raw_dec.offset = p_dec->offset; 
            raw_dec.start[0] = p_dec->start[0]; 
            raw_dec.start[1] = p_dec->start[1]; 
            raw_dec.count[0] = p_dec->count[0]; 
            raw_dec.count[1] = p_dec->count[1]; 
            raw_dec.interlaced = p_dec->interlaced; 
            raw_dec.synchronous = p_dec->synchronous; 

            vbi_raw_decoder_add_services(&raw_dec, ALL_SERVICES_525|ALL_SERVICES_625, 0);
         }
      }

      update_services = (opt_scanning != 0);

      while(1)
      {
         fd_set rd;
         int vbi_fd = vbi_capture_fd(pVbiCapt);
         if (vbi_fd == -1)
            break;

         FD_ZERO(&rd);
         FD_SET(vbi_fd, &rd);
         FD_SET(0, &rd);
         select(vbi_fd + 1, &rd, NULL, NULL, NULL);

         if (FD_ISSET(0, &rd))
         {
            new_services = read_service_string();
            if (opt_scanning == TEST_SCANNING_625)
               new_services &= ALL_SERVICES_625;
            else if (opt_scanning == TEST_SCANNING_525)
               new_services &= ALL_SERVICES_525;
            if (new_services != opt_services)
            {
               fprintf(stderr, "switching service from 0x%X to 0x%X...\n", opt_services, new_services);
               opt_services = new_services;
               update_services = TRUE;
            }
         }
         if (update_services)
         {
            cur_services = vbi_capture_update_services(pVbiCapt, TRUE, TRUE,
                                                       opt_services, opt_strict, &pErr);
            if ((cur_services != 0) || (opt_services == 0))
               fprintf(stderr, "...got granted services 0x%X.\n", cur_services);
            else
               fprintf(stderr, "...failed: %s\n", ((pErr != NULL) ? pErr : ""));
            lastLineCount = 0;
            update_services = FALSE;
         }

         if (FD_ISSET(vbi_fd, &rd))
         {
            timeout.tv_sec  = 0;
            timeout.tv_usec = 1000;

            if ((opt_services & (VBI_SLICED_VBI_625 | VBI_SLICED_VBI_525)) == 0)
            {
               res = vbi_capture_pull_sliced(pVbiCapt, &pVbiBuf, &timeout);
               if (res < 0)
               {
                  fprintf(stderr, "VBI read error: %d (%s)\n", errno, strerror(errno));
                  break;
               }
               else if ((res > 0) && (pVbiBuf != NULL))
               {
                  lineCount = ((unsigned int) pVbiBuf->size) / sizeof(vbi_sliced);
                  pVbiData  = pVbiBuf->data;

                  if (lastLineCount != lineCount)
                  {
                     fprintf(stderr, "%d lines\n", lineCount);
                     lastLineCount = lineCount;
                  }

                  for (line=0; line < lineCount; line++)
                  {
                     if ((pVbiData[line].id & (VBI_SLICED_TELETEXT_B | VBI_SLICED_TELETEXT_BD_525)) != 0)
                     {
                        PrintTeletextData(pVbiData[line].data, pVbiData[line].line, pVbiData[line].id);
                     }
                     else if (pVbiData[line].id == VBI_SLICED_VPS)
                     {
                        PrintVpsData(pVbiData[line].data);
                     }
                     else if (pVbiData[line].id == VBI_SLICED_WSS_625)
                     {
                        printf("WSS 0x%02X%02X%02X\n", pVbiData[line].data[0], pVbiData[line].data[1], pVbiData[line].data[2]);
                     }
                  }
               }
               else
                  fprintf(stderr, "proxy-test: timeout in VBI read\n");
            }
            else
            {
               res = vbi_capture_pull_raw(pVbiCapt, &pVbiBuf, &timeout);
               if ((res < 0) && (errno != EAGAIN))
               {
                  fprintf(stderr, "VBI read error: %d (%s)\n", errno, strerror(errno));
                  break;
               }
               else if ((res > 0) && (pVbiBuf != NULL))
               {
#ifdef USE_LIBZVBI
                  pVbiData = malloc(32 * sizeof(vbi_sliced));
                  lineCount = vbi_raw_decode(&raw_dec, pVbiBuf->data, pVbiData);

                  if (lastLineCount != lineCount)
                  {
                     fprintf(stderr, "%d lines\n", lineCount);
                     lastLineCount = lineCount;
                  }

                  for (line=0; line < lineCount; line++)
                  {
                     if ((pVbiData[line].id & (VBI_SLICED_TELETEXT_B|VBI_SLICED_TELETEXT_BD_525)) != 0)
                     {
                        PrintTeletextData(pVbiData[line].data, pVbiData[line].line, pVbiData[line].id);
                     }
                     else if (pVbiData[line].id == VBI_SLICED_VPS)
                     {
                        PrintVpsData(pVbiData[line].data);
                     }
                     else if (pVbiData[line].id == VBI_SLICED_WSS_625)
                     {
                        printf("WSS 0x%02X%02X%02X\n", pVbiData[line].data[0], pVbiData[line].data[1], pVbiData[line].data[2]);
                     }
                  }
                  free(pVbiData);
#endif  /* USE_LIBZVBI */
               }
               else if (opt_debug_level > 0)
               {
                  fprintf(stderr, "VBI read timeout\n");
               }
            }
         }
      }

      vbi_capture_delete(pVbiCapt);
   }
   else
   {
      if (pErr != NULL)
      {
         fprintf(stderr, "libzvbi error: %s\n", pErr);
         free(pErr);
      }
      else
         fprintf(stderr, "error starting acquisition\n");
   }
   if (pProxyClient != NULL)
   {
      vbi_proxy_client_destroy(pProxyClient);
      pProxyClient = NULL;
   }
   exit(0);
   return(0);
}